Fix recordings dying mid-stream; record to growing .ts with live buffer playback

A recording of a live event crashed partway through: when its short
Akamai token expired, the proxy's stale-alias check swapped the
recording's mapping to the most recently registered deferred stream,
of any content. Segment requests were then built against the wrong CDN
path, returned 403, and ffmpeg exited, splitting the recording into
several files.

Proxy:
- Never swap URN-backed livestreams; they refresh themselves from the
  API. Only consider swap candidates with the same URN.

Recording lifecycle:
- Complete a recording once its stream has been gone from the API for
  5 minutes (broadcasts can end before ValidTo).
- Fail a recording still waiting for its stream after ValidTo (or 12h
  after ValidFrom) instead of retrying forever.
- Wait for a DVR window whose start= is still in the future instead of
  starting ffmpeg against a 400/404.
- Keep the original start time across restarts; don't mark a recording
  failed on shutdown cancellation.

Growing .ts recordings:
- ffmpeg writes MPEG-TS (-c copy -copyts) to stdout and the plugin
  appends it to one file per recording, so restarts continue the same
  file and timeline.
- The Recordings folder lists any recording with a file on disk, not
  only completed ones.
- In-progress recordings are exposed as infinite streams reading through
  a new endpoint that follows the growing file (same pattern as
  Jellyfin's DVR), so they can be watched from the start like a
  livestream buffer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.gitea/runner/cloud-init.yaml

@@ -0,0 +1,58 @@
+#cloud-config
+# Gitea Actions runner on an Oracle Cloud Always Free Ampere (ARM) VM, shared by
+# every repo on the instance.
+#
+# Paste this into "Advanced options -> Management -> Initialization script" when
+# creating the instance (image: Canonical Ubuntu 24.04, shape: VM.Standard.A1.Flex).
+# Before pasting, replace REGISTRATION_TOKEN below with an instance-wide token:
+#   Site Administration -> Actions -> Runners -> Create new runner
+# (a token from repo Settings would limit the runner to that one repo).
+#
+# The runner only makes outbound connections (to Gitea and container registries),
+# so the VM needs no inbound ports beyond SSH.
+#
+# Labels follow the instance convention (same set as the freebox ARM runner).
+# ubuntu-latest / ubuntu-22.04 are shared with the amd64 runner, so a job asking
+# for them may land on either architecture; ask for linux/arm64 or linux/amd64
+# when a job needs a specific one. SRF Play jobs run in the multi-arch
+# srfplay-builder image, so they work on both.
+
+# Optional: a password for the "ubuntu" user, so you can log in through the Oracle
+# serial console ("Launch Cloud Shell connection") without an SSH key. Generate the
+# hash locally with:  openssl passwd -6
+# then uncomment and paste it in. SSH still only accepts keys.
+#chpasswd:
+#  expire: false
+#  users:
+#    - name: ubuntu
+#      password: "$6$...paste the hash here..."
+
+package_update: true
+packages:
+  - docker.io
+  - docker-compose-v2
+
+write_files:
+  - path: /opt/act_runner/docker-compose.yml
+    permissions: "0600"
+    content: |
+      services:
+        runner:
+          image: gitea/act_runner:latest
+          restart: unless-stopped
+          environment:
+            GITEA_INSTANCE_URL: https://gitea.tourolle.paris
+            GITEA_RUNNER_REGISTRATION_TOKEN: REGISTRATION_TOKEN
+            GITEA_RUNNER_NAME: oracle-a1
+            # Comma-separated with no spaces: label:docker://<default job image>
+            GITEA_RUNNER_LABELS: "ubuntu-latest:docker://gitea/runner-images:ubuntu-latest,ubuntu-22.04:docker://gitea/runner-images:ubuntu-22.04,linux-arm64:docker://gitea/runner-images:ubuntu-latest,self-hosted:docker://gitea/runner-images:ubuntu-latest,linux/arm64:docker://gitea/runner-images:ubuntu-latest"
+          volumes:
+            # Registration is stored here, so the token is only used once.
+            - ./data:/data
+            - /var/run/docker.sock:/var/run/docker.sock
+
+runcmd:
+  - systemctl enable --now docker
+  - cd /opt/act_runner && docker compose up -d
+  # Weekly clean-up so pulled images and build caches do not fill the boot volume.
+  - echo '0 4 * * 0 root docker system prune -af --filter "until=168h" >/dev/null 2>&1' > /etc/cron.d/docker-prune

.gitea/workflows/build.yaml

@@ -15,7 +15,7 @@ on:
 
 jobs:
   build:
-    runs-on: linux/amd64
+    runs-on: ubuntu-latest
     container:
       image: gitea.tourolle.paris/dtourolle/srfplay-builder:latest
 

.gitea/workflows/latest.yaml

@@ -11,7 +11,7 @@ on:
 
 jobs:
   nightly-build:
-    runs-on: linux/amd64
+    runs-on: ubuntu-latest
     container:
       image: gitea.tourolle.paris/dtourolle/srfplay-builder:latest
 
@@ -111,14 +111,14 @@ jobs:
           fi
 
           # Upload one plugin zip per Jellyfin generation
-          while IFS=$'\t' read -r _ _ ZIP _; do
+          cut -f3 artifacts/builds.tsv | while read -r ZIP; do
             echo "Uploading ${ZIP}..."
             curl -f -X POST \
               -H "Authorization: token ${GITEA_TOKEN}" \
               -H "Content-Type: application/zip" \
               --data-binary "@${ZIP}" \
               "${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases/${RELEASE_ID}/assets?name=$(basename "${ZIP}")"
-          done < artifacts/builds.tsv
+          done
 
           # Upload build.yaml
           echo "Uploading build.yaml..."

.gitea/workflows/release.yaml

@@ -13,7 +13,7 @@ on:
 
 jobs:
   build-and-release:
-    runs-on: linux/amd64
+    runs-on: ubuntu-latest
     container:
       image: gitea.tourolle.paris/dtourolle/srfplay-builder:latest
 
@@ -91,14 +91,14 @@ jobs:
           fi
 
           # Upload one plugin zip per Jellyfin generation
-          while IFS=$'\t' read -r _ _ ZIP _; do
+          cut -f3 artifacts/builds.tsv | while read -r ZIP; do
             echo "Uploading ${ZIP}..."
             curl -f -X POST \
               -H "Authorization: token ${GITEA_TOKEN}" \
               -H "Content-Type: application/zip" \
               --data-binary "@${ZIP}" \
               "${GITEA_URL}/api/v1/repos/${REPO_OWNER}/${REPO_NAME}/releases/${RELEASE_ID}/assets?name=$(basename "${ZIP}")"
-          done < artifacts/builds.tsv
+          done
 
           # Upload build.yaml
           echo "Uploading build.yaml..."

.gitea/workflows/test.yaml

@@ -17,7 +17,7 @@ on:
 
 jobs:
   test:
-    runs-on: linux/amd64
+    runs-on: ubuntu-latest
     container:
       image: gitea.tourolle.paris/dtourolle/srfplay-builder:latest
 

.gitignore

@@ -4,3 +4,4 @@ obj/
 .idea/
 artifacts
 *.log
+.test-plugin/

Dockerfile.builder

@@ -1,7 +1,10 @@
 # SRFPlay Builder Image
 # Pre-built image with .NET SDK and JPRM for building Jellyfin plugins
-# Build: docker build -f Dockerfile.builder -t gitea.tourolle.paris/dtourolle/srfplay-builder:latest .
+# Multi-arch (amd64 + arm64) so runners on ARM hosts such as Oracle Cloud's free
-# Push:  docker push gitea.tourolle.paris/dtourolle/srfplay-builder:latest
+# Ampere VMs can use it too; the plugin DLLs it produces are identical either way.
+# Build + push (needs a docker-container buildx builder and arm64 binfmt/QEMU):
+#   docker buildx build -f Dockerfile.builder --platform linux/amd64,linux/arm64 \
+#       -t gitea.tourolle.paris/dtourolle/srfplay-builder:latest --push .
 
 FROM mcr.microsoft.com/dotnet/sdk:10.0
 

Dockerfile.test

@@ -0,0 +1,23 @@
+# Test image: stock Jellyfin with a prebuilt SRF Play plugin baked in.
+#
+# This does NOT build the plugin — build it first on the host (fast, warm
+# NuGet cache), then this image is just one small COPY on top of stock
+# Jellyfin, so it builds in seconds.
+#
+#   ./test-image.sh            # builds plugin + image, runs it
+#
+# or manually:
+#   dotnet publish Jellyfin.Plugin.SRFPlay/Jellyfin.Plugin.SRFPlay.csproj \
+#       -c Release -f net10.0 --no-self-contained -o ./.test-plugin/SRFPlay
+#   docker build -f Dockerfile.test --build-arg JELLYFIN_TAG=12 -t srfplay-test .
+#   docker run --rm -p 8096:8096 srfplay-test
+#
+# JELLYFIN_TAG must match the framework the plugin was published for;
+# test-image.sh picks both from one setting.
+
+ARG JELLYFIN_TAG=12
+FROM jellyfin/jellyfin:${JELLYFIN_TAG}
+
+# .test-plugin/SRFPlay is produced by test-image.sh and contains the plugin
+# DLL plus a generated meta.json. Jellyfin loads from <config>/plugins.
+COPY .test-plugin/SRFPlay /config/plugins/SRFPlay

Jellyfin.Plugin.SRFPlay/Api/Models/RecordingEntry.cs

@@ -81,6 +81,13 @@ public class RecordingEntry
     [JsonPropertyName("recordingEndedAt")]
     public DateTime? RecordingEndedAt { get; set; }
 
+    /// <summary>
+    /// Gets or sets when the stream disappeared from the API after recording had started.
+    /// Used to detect that a broadcast ended before its scheduled ValidTo.
+    /// </summary>
+    [JsonPropertyName("streamLostAt")]
+    public DateTime? StreamLostAt { get; set; }
+
     /// <summary>
     /// Gets or sets the file size in bytes.
     /// </summary>
@@ -98,4 +105,10 @@ public class RecordingEntry
     /// </summary>
     [JsonPropertyName("createdAt")]
     public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+    /// <summary>
+    /// Gets a value indicating whether the output file may still grow (recording, or waiting to resume).
+    /// </summary>
+    [JsonIgnore]
+    public bool IsInProgress => State is RecordingState.Recording or RecordingState.WaitingForStream;
 }

Jellyfin.Plugin.SRFPlay/Channels/SrgChannelBase.cs

@@ -28,6 +28,8 @@ namespace Jellyfin.Plugin.SRFPlay.Channels;
 /// </summary>
 public abstract class SrgChannelBase : IChannel, IHasCacheKey
 {
+    private const string InProgressPrefix = "● REC · ";
+
     private readonly ILogger<SrgChannelBase> _logger;
     private readonly IContentRefreshService _contentRefreshService;
     private readonly IStreamUrlResolver _streamResolver;
@@ -303,8 +305,8 @@ public abstract class SrgChannelBase : IChannel, IHasCacheKey
                 if (matchingEvent?.ValidFrom != null)
                 {
                     var eventTime = matchingEvent.ValidFrom.Value;
-                    item.Name = $"[{eventTime:dd.MM HH:mm}] {matchingEvent.Title}";
+                    item.Name = $"[{DisplayTime.From(eventTime):dd.MM HH:mm}] {matchingEvent.Title}";
-                    item.PremiereDate = eventTime;
+                    item.PremiereDate = eventTime.ToUniversalTime();
                 }
             }
         }
@@ -320,15 +322,10 @@ public abstract class SrgChannelBase : IChannel, IHasCacheKey
     {
         var items = new List<ChannelItemInfo>();
         var unit = Unit.ToLowerString();
-        var recordings = _recordingService.GetRecordings(RecordingState.Completed);
+        var serverBaseUrl = _mediaSourceFactory.GetServerBaseUrl();
 
-        foreach (var recording in recordings)
+        foreach (var recording in _recordingService.GetPlayableRecordings())
         {
-            if (string.IsNullOrEmpty(recording.OutputPath) || !System.IO.File.Exists(recording.OutputPath))
-            {
-                continue;
-            }
-
             // Only show recordings belonging to this unit. Recordings created before the
             // BusinessUnit tag existed have an empty value and are shown everywhere so they
             // are not lost.
@@ -338,43 +335,72 @@ public abstract class SrgChannelBase : IChannel, IHasCacheKey
                 continue;
             }
 
-            var fileInfo = new System.IO.FileInfo(recording.OutputPath);
+            var outputPath = recording.OutputPath!;
             var itemId = $"recording_{recording.Id}";
+            var container = System.IO.Path.GetExtension(outputPath).TrimStart('.').ToLowerInvariant();
+            var name = recording.IsInProgress ? $"{InProgressPrefix}{recording.Title}" : recording.Title;
 
-            var mediaSource = new MediaSourceInfo
+            MediaSourceInfo mediaSource;
+            if (recording.IsInProgress)
             {
-                Id = itemId,
+                // Same approach as Jellyfin's own DVR: the file is still growing, so treat it as a live
-                Name = recording.Title,
+                // stream and have ffmpeg read it through an endpoint that follows the file.
-                Path = recording.OutputPath,
+                mediaSource = new MediaSourceInfo
-                Protocol = MediaProtocol.File,
+                {
-                Container = "mkv",
+                    Id = itemId,
-                SupportsDirectPlay = true,
+                    Name = name,
-                SupportsDirectStream = true,
+                    Path = outputPath,
-                SupportsTranscoding = true,
+                    Protocol = MediaProtocol.File,
-                IsRemote = false,
+                    EncoderPath = $"{serverBaseUrl}/Plugins/SRFPlay/Recording/{recording.Id}/stream",
-                Size = fileInfo.Length,
+                    EncoderProtocol = MediaProtocol.Http,
-                Type = MediaSourceType.Default
+                    Container = container,
-            };
+                    SupportsDirectPlay = false,
+                    SupportsDirectStream = true,
+                    SupportsTranscoding = true,
+                    IsInfiniteStream = true,
+                    IgnoreDts = true,
+                    IgnoreIndex = true,
+                    IsRemote = false,
+                    Type = MediaSourceType.Default
+                };
+            }
+            else
+            {
+                mediaSource = new MediaSourceInfo
+                {
+                    Id = itemId,
+                    Name = name,
+                    Path = outputPath,
+                    Protocol = MediaProtocol.File,
+                    Container = container,
+                    SupportsDirectPlay = true,
+                    SupportsDirectStream = true,
+                    SupportsTranscoding = true,
+                    IsRemote = false,
+                    Size = new System.IO.FileInfo(outputPath).Length,
+                    Type = MediaSourceType.Default
+                };
+            }
 
             var item = new ChannelItemInfo
             {
                 Id = itemId,
-                Name = recording.Title,
+                Name = name,
                 Overview = recording.Description,
                 Type = ChannelItemType.Media,
                 ContentType = ChannelMediaContentType.Movie,
                 MediaType = ChannelMediaType.Video,
                 DateCreated = recording.RecordingStartedAt,
                 ImageUrl = !string.IsNullOrEmpty(recording.ImageUrl)
-                    ? CreateProxiedImageUrl(recording.ImageUrl, _mediaSourceFactory.GetServerBaseUrl())
+                    ? CreateProxiedImageUrl(recording.ImageUrl, serverBaseUrl)
-                    : CreatePlaceholderImageUrl(recording.Title, _mediaSourceFactory.GetServerBaseUrl()),
+                    : CreatePlaceholderImageUrl(recording.Title, serverBaseUrl),
                 MediaSources = new List<MediaSourceInfo> { mediaSource }
             };
 
             items.Add(item);
         }
 
-        _logger.LogInformation("Returning {Count} completed recordings as channel items", items.Count);
+        _logger.LogInformation("Returning {Count} recordings as channel items", items.Count);
         return items;
     }
 
@@ -492,8 +518,10 @@ public abstract class SrgChannelBase : IChannel, IHasCacheKey
         var timeBucket = new DateTime(now.Year, now.Month, now.Day, now.Hour, (now.Minute / 15) * 15, 0);
         var timeKey = timeBucket.ToString("yyyy-MM-dd-HH-mm", CultureInfo.InvariantCulture);
 
-        var recordingCount = _recordingService.GetRecordings(RecordingState.Completed).Count;
+        // Include in-progress count so items switch from live to finished sources when a recording ends
-        return $"{Unit}_{config?.EnableLatestContent}_{config?.EnableTrendingContent}_{config?.EnableCategoryFolders}_{enabledTopics}_{timeKey}_rec{recordingCount}";
+        var recordings = _recordingService.GetPlayableRecordings();
+        var recordingKey = $"{recordings.Count}_{recordings.Count(r => r.IsInProgress)}";
+        return $"{Unit}_{config?.EnableLatestContent}_{config?.EnableTrendingContent}_{config?.EnableCategoryFolders}_{enabledTopics}_{timeKey}_rec{recordingKey}";
     }
 
     private async Task<List<ChannelItemInfo>> ConvertUrnsToChannelItems(List<string> urns, CancellationToken cancellationToken)

Jellyfin.Plugin.SRFPlay/Configuration/PluginConfiguration.cs

@@ -169,6 +169,14 @@ public class PluginConfiguration : BasePluginConfiguration
     /// </summary>
     public string RecordingOutputPath { get; set; } = string.Empty;
 
+    /// <summary>
+    /// Gets or sets the time zone used for times the plugin writes as text: the start time in
+    /// upcoming livestream names and the timestamp in recording file names. An IANA id such as
+    /// "Europe/Zurich"; empty uses the server's time zone. Dates Jellyfin shows itself (e.g.
+    /// PremiereDate) are stored as UTC and follow each viewer's own time zone regardless.
+    /// </summary>
+    public string DisplayTimeZone { get; set; } = string.Empty;
+
     /// <summary>
     /// Gets or sets how many segments back from the live edge livestream playback should start.
     /// Injected as <c>#EXT-X-START:TIME-OFFSET=-(N * targetDuration)</c> into the live media

Jellyfin.Plugin.SRFPlay/Configuration/configPage.html

@@ -82,6 +82,11 @@
                         <input id="RecordingOutputPath" name="RecordingOutputPath" type="text" is="emby-input" placeholder="e.g., /media/recordings/srf" />
                         <div class="fieldDescription">Directory where sport livestream recordings will be saved (requires ffmpeg)</div>
                     </div>
+                    <div class="inputContainer">
+                        <label class="inputLabel inputLabelUnfocused" for="DisplayTimeZone">Display Time Zone</label>
+                        <input id="DisplayTimeZone" name="DisplayTimeZone" type="text" is="emby-input" placeholder="e.g., Europe/Zurich" />
+                        <div class="fieldDescription">Time zone for start times in upcoming livestream names and for recording file names. Leave empty to use the server's time zone.</div>
+                    </div>
                     <div class="inputContainer">
                         <label class="inputLabel inputLabelUnfocused" for="LiveStartSegmentsBack">Live Start Offset (segments)</label>
                         <input id="LiveStartSegmentsBack" name="LiveStartSegmentsBack" type="number" is="emby-input" min="0" max="20" />
@@ -200,6 +205,7 @@
                         document.querySelector('#ProxyPassword').value = config.ProxyPassword || '';
                         document.querySelector('#PublicServerUrl').value = config.PublicServerUrl || '';
                         document.querySelector('#RecordingOutputPath').value = config.RecordingOutputPath || '';
+                        document.querySelector('#DisplayTimeZone').value = config.DisplayTimeZone || '';
                         document.querySelector('#LiveStartSegmentsBack').value = config.LiveStartSegmentsBack != null ? config.LiveStartSegmentsBack : 3;
                         document.querySelector('#CleanUpResumePoints').checked = config.CleanUpResumePoints !== false;
                         document.querySelector('#ClearLiveStreamResumePoints').checked = config.ClearLiveStreamResumePoints !== false;
@@ -231,6 +237,7 @@
                     config.ProxyPassword = document.querySelector('#ProxyPassword').value;
                     config.PublicServerUrl = document.querySelector('#PublicServerUrl').value;
                     config.RecordingOutputPath = document.querySelector('#RecordingOutputPath').value;
+                    config.DisplayTimeZone = document.querySelector('#DisplayTimeZone').value.trim();
                     config.LiveStartSegmentsBack = parseInt(document.querySelector('#LiveStartSegmentsBack').value) || 0;
                     config.CleanUpResumePoints = document.querySelector('#CleanUpResumePoints').checked;
                     config.ClearLiveStreamResumePoints = document.querySelector('#ClearLiveStreamResumePoints').checked;

Jellyfin.Plugin.SRFPlay/Controllers/RecordingController.cs

@@ -1,4 +1,6 @@
+using System;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
@@ -19,6 +21,9 @@ namespace Jellyfin.Plugin.SRFPlay.Controllers;
 [Authorize]
 public class RecordingController : ControllerBase
 {
+    /// <summary>How long a followed stream waits at the end of an in-progress file before giving up.</summary>
+    private static readonly TimeSpan FollowIdleTimeout = TimeSpan.FromMinutes(2);
+
     private readonly ILogger<RecordingController> _logger;
     private readonly IRecordingService _recordingService;
 
@@ -56,6 +61,67 @@ public class RecordingController : ControllerBase
         return File(resourceStream, "text/html");
     }
 
+    /// <summary>
+    /// Streams a recording's .ts file. While the recording is still in progress this keeps
+    /// following the file as it grows, so it can be watched like a livestream buffer.
+    /// </summary>
+    /// <param name="id">The recording ID.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>The MPEG-TS stream.</returns>
+    [HttpGet("{id}/stream")]
+    [AllowAnonymous] // Fetched server-side by Jellyfin/ffmpeg without a token, like the stream proxy
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetRecordingStream(string id, CancellationToken cancellationToken)
+    {
+        // The path always comes from our own recording list (which only contains existing files),
+        // never from the request
+        var entry = _recordingService.GetPlayableRecordings().FirstOrDefault(r => r.Id == id);
+        if (entry?.OutputPath is not { } path)
+        {
+            return NotFound();
+        }
+
+        Response.ContentType = "video/mp2t";
+
+        var input = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete, 81920, FileOptions.Asynchronous | FileOptions.SequentialScan);
+        await using (input.ConfigureAwait(false))
+        {
+            var buffer = new byte[81920];
+            var lastDataAt = DateTime.UtcNow;
+
+            try
+            {
+                while (true)
+                {
+                    var read = await input.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
+                    if (read > 0)
+                    {
+                        await Response.Body.WriteAsync(buffer.AsMemory(0, read), cancellationToken).ConfigureAwait(false);
+                        lastDataAt = DateTime.UtcNow;
+                        continue;
+                    }
+
+                    // At the end of the file: keep following while it's still being written. The idle
+                    // limit covers an ffmpeg restart but ends the stream if recording has stalled.
+                    var stillRecording = _recordingService.GetRecording(id)?.IsInProgress == true;
+                    if (!stillRecording || DateTime.UtcNow - lastDataAt > FollowIdleTimeout)
+                    {
+                        break;
+                    }
+
+                    await Task.Delay(500, cancellationToken).ConfigureAwait(false);
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                // Client went away
+            }
+        }
+
+        return new EmptyResult();
+    }
+
     /// <summary>
     /// Gets upcoming sport livestreams available for recording.
     /// </summary>

Jellyfin.Plugin.SRFPlay/Services/Interfaces/IRecordingService.cs

@@ -47,6 +47,19 @@ public interface IRecordingService
     /// <returns>List of matching recording entries.</returns>
     IReadOnlyList<RecordingEntry> GetRecordings(RecordingState? stateFilter = null);
 
+    /// <summary>
+    /// Gets a single recording by ID.
+    /// </summary>
+    /// <param name="recordingId">The recording ID.</param>
+    /// <returns>The recording entry, or null if not found.</returns>
+    RecordingEntry? GetRecording(string recordingId);
+
+    /// <summary>
+    /// Gets recordings that have an output file on disk, finished or still in progress.
+    /// </summary>
+    /// <returns>Playable recordings, newest first.</returns>
+    IReadOnlyList<RecordingEntry> GetPlayableRecordings();
+
     /// <summary>
     /// Deletes a completed recording (entry and optionally the file).
     /// </summary>

Jellyfin.Plugin.SRFPlay/Services/RecordingService.cs

@@ -25,6 +25,15 @@ namespace Jellyfin.Plugin.SRFPlay.Services;
 /// </summary>
 public class RecordingService : IRecordingService, IDisposable
 {
+    /// <summary>How long the stream may be missing from the API mid-recording before we treat the broadcast as over.</summary>
+    private static readonly TimeSpan StreamLostGracePeriod = TimeSpan.FromMinutes(5);
+
+    /// <summary>When a recording has no ValidTo, how long after ValidFrom to keep waiting for the stream.</summary>
+    private static readonly TimeSpan NoValidToGiveUpAfter = TimeSpan.FromHours(12);
+
+    /// <summary>Longest the scheduler will block waiting for an imminent DVR window start.</summary>
+    private static readonly TimeSpan MaxInlineStartWait = TimeSpan.FromSeconds(60);
+
     private readonly ILogger<RecordingService> _logger;
     private readonly ISRFApiClientFactory _apiClientFactory;
     private readonly IStreamProxyService _proxyService;
@@ -32,7 +41,7 @@ public class RecordingService : IRecordingService, IDisposable
     private readonly IMediaCompositionFetcher _mediaCompositionFetcher;
     private readonly IServerApplicationHost _appHost;
     private readonly IMediaEncoder _mediaEncoder;
-    private readonly ConcurrentDictionary<string, Process> _activeProcesses = new();
+    private readonly ConcurrentDictionary<string, ActiveRecording> _activeProcesses = new();
     private static readonly JsonSerializerOptions _jsonOptions = new() { WriteIndented = true };
     private readonly SemaphoreSlim _persistLock = new(1, 1);
     private readonly SemaphoreSlim _processLock = new(1, 1);
@@ -266,15 +275,7 @@ public class RecordingService : IRecordingService, IDisposable
         }
 
         StopFfmpeg(recordingId);
-
+        CompleteRecording(entry, DateTime.UtcNow);
-        entry.State = RecordingState.Completed;
-        entry.RecordingEndedAt = DateTime.UtcNow;
-
-        if (entry.OutputPath != null && File.Exists(entry.OutputPath))
-        {
-            entry.FileSizeBytes = new FileInfo(entry.OutputPath).Length;
-        }
-
         _ = SaveRecordingsAsync();
 
         _logger.LogInformation("Stopped recording '{Title}' ({Id})", entry.Title, recordingId);
@@ -298,6 +299,22 @@ public class RecordingService : IRecordingService, IDisposable
         return _recordings.OrderByDescending(r => r.CreatedAt).ToList();
     }
 
+    /// <inheritdoc />
+    public RecordingEntry? GetRecording(string recordingId)
+    {
+        return GetRecordings(null).FirstOrDefault(r => r.Id == recordingId);
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<RecordingEntry> GetPlayableRecordings()
+    {
+        // Gate on the file rather than the state: an in-progress or failed recording
+        // still has watchable footage.
+        return GetRecordings(null)
+            .Where(r => !string.IsNullOrEmpty(r.OutputPath) && File.Exists(r.OutputPath))
+            .ToList();
+    }
+
     /// <inheritdoc />
     public bool DeleteRecording(string recordingId, bool deleteFile)
     {
@@ -369,8 +386,26 @@ public class RecordingService : IRecordingService, IDisposable
             {
                 case RecordingState.Scheduled:
                 case RecordingState.WaitingForStream:
-                    // Check if it's time to start recording
+                    // Give up once the broadcast window is over, otherwise we'd retry forever
-                    if (validFromUtc.HasValue && validFromUtc.Value <= now.AddMinutes(2))
+                    var giveUpAt = validToUtc ?? validFromUtc?.Add(NoValidToGiveUpAfter);
+                    if (giveUpAt.HasValue && giveUpAt.Value <= now)
+                    {
+                        if (entry.RecordingStartedAt.HasValue)
+                        {
+                            _logger.LogInformation("Recording '{Title}' reached end of broadcast window while waiting for stream, completing", entry.Title);
+                            CompleteRecording(entry, now);
+                        }
+                        else
+                        {
+                            _logger.LogWarning("Stream for '{Title}' never became available (window ended {GiveUpAt}), marking failed", entry.Title, giveUpAt.Value);
+                            entry.State = RecordingState.Failed;
+                            entry.ErrorMessage = "Stream never became available";
+                            entry.RecordingEndedAt = now;
+                        }
+
+                        changed = true;
+                    }
+                    else if (validFromUtc.HasValue && validFromUtc.Value <= now.AddMinutes(2))
                     {
                         _logger.LogInformation(
                             "Time to start recording '{Title}': ValidFrom={ValidFrom} (UTC: {ValidFromUtc}), Now={Now}",
@@ -389,13 +424,7 @@ public class RecordingService : IRecordingService, IDisposable
                     {
                         _logger.LogInformation("Recording '{Title}' reached ValidTo, stopping", entry.Title);
                         StopFfmpeg(entry.Id);
-                        entry.State = RecordingState.Completed;
+                        CompleteRecording(entry, now);
-                        entry.RecordingEndedAt = now;
-                        if (entry.OutputPath != null && File.Exists(entry.OutputPath))
-                        {
-                            entry.FileSizeBytes = new FileInfo(entry.OutputPath).Length;
-                        }
-
                         changed = true;
                     }
                     else if (!_activeProcesses.ContainsKey(entry.Id))
@@ -426,7 +455,7 @@ public class RecordingService : IRecordingService, IDisposable
             if (chapter == null)
             {
                 _logger.LogDebug("No chapter found for '{Title}', stream may not be live yet", entry.Title);
-                entry.State = RecordingState.WaitingForStream;
+                MarkStreamUnavailable(entry);
                 return true;
             }
 
@@ -437,10 +466,29 @@ public class RecordingService : IRecordingService, IDisposable
             if (string.IsNullOrEmpty(streamUrl))
             {
                 _logger.LogDebug("No stream URL available for '{Title}', waiting", entry.Title);
-                entry.State = RecordingState.WaitingForStream;
+                MarkStreamUnavailable(entry);
                 return true;
             }
 
+            // The CDN rejects a DVR window whose start= is still in the future (400/404).
+            // Wait briefly if it's imminent, otherwise try again on the next scheduler run.
+            var windowStart = GetDvrWindowStart(streamUrl);
+            if (windowStart.HasValue && windowStart.Value > DateTime.UtcNow)
+            {
+                var wait = windowStart.Value - DateTime.UtcNow + TimeSpan.FromSeconds(5);
+                if (wait > MaxInlineStartWait)
+                {
+                    _logger.LogInformation("Stream for '{Title}' starts at {Start}, waiting", entry.Title, windowStart.Value);
+                    entry.State = RecordingState.WaitingForStream;
+                    return true;
+                }
+
+                _logger.LogInformation("Stream for '{Title}' starts in {Seconds:F0}s, delaying ffmpeg start", entry.Title, wait.TotalSeconds);
+                await Task.Delay(wait, cancellationToken).ConfigureAwait(false);
+            }
+
+            entry.StreamLostAt = null;
+
             // Register the stream with the proxy so we can use the proxy URL
             var itemId = $"rec_{entry.Id}";
             var isLiveStream = chapter.Type == "SCHEDULED_LIVESTREAM" || UrnHelper.IsLivestreamUrn(entry.Urn);
@@ -449,22 +497,26 @@ public class RecordingService : IRecordingService, IDisposable
             // Build proxy URL for ffmpeg (use localhost for local access)
             var proxyUrl = $"{GetServerBaseUrl()}/Plugins/SRFPlay/Proxy/{itemId}/master.m3u8";
 
-            // Build output file path
+            // Restarts append to the existing .ts so a recording stays one file
-            var safeTitle = SanitizeFileName(entry.Title);
+            var outputPath = entry.OutputPath;
-            var timestamp = DateTime.Now.ToString("yyyy-MM-dd_HHmm", CultureInfo.InvariantCulture);
+            if (string.IsNullOrEmpty(outputPath) || !outputPath.EndsWith(".ts", StringComparison.OrdinalIgnoreCase))
-            var outputPath = Path.Combine(GetRecordingOutputPath(), $"{safeTitle}_{timestamp}.mkv");
+            {
-            entry.OutputPath = outputPath;
+                var safeTitle = SanitizeFileName(entry.Title);
+                var timestamp = DisplayTime.Now().ToString("yyyy-MM-dd_HHmm", CultureInfo.InvariantCulture);
+                outputPath = Path.Combine(GetRecordingOutputPath(), $"{safeTitle}_{timestamp}.ts");
+                entry.OutputPath = outputPath;
+            }
 
             // Start ffmpeg
             StartFfmpeg(entry.Id, proxyUrl, outputPath);
 
             entry.State = RecordingState.Recording;
-            entry.RecordingStartedAt = DateTime.UtcNow;
+            entry.RecordingStartedAt ??= DateTime.UtcNow;
 
             _logger.LogInformation("Started recording '{Title}' to {OutputPath}", entry.Title, outputPath);
             return true;
         }
-        catch (Exception ex)
+        catch (Exception ex) when (ex is not OperationCanceledException)
         {
             _logger.LogError(ex, "Failed to start recording '{Title}'", entry.Title);
             entry.State = RecordingState.Failed;
@@ -473,6 +525,61 @@ public class RecordingService : IRecordingService, IDisposable
         }
     }
 
+    /// <summary>
+    /// Handles the API no longer offering a stream. Before recording starts this just means "not live yet";
+    /// once recording has started it means the broadcast ended (possibly before ValidTo).
+    /// </summary>
+    private void MarkStreamUnavailable(RecordingEntry entry)
+    {
+        if (!entry.RecordingStartedAt.HasValue)
+        {
+            entry.State = RecordingState.WaitingForStream;
+            return;
+        }
+
+        var now = DateTime.UtcNow;
+        entry.StreamLostAt ??= now;
+
+        if (now - entry.StreamLostAt.Value >= StreamLostGracePeriod)
+        {
+            _logger.LogInformation(
+                "Stream for '{Title}' has been gone since {LostAt}, broadcast has ended - completing recording",
+                entry.Title,
+                entry.StreamLostAt.Value);
+            StopFfmpeg(entry.Id);
+            CompleteRecording(entry, now);
+            return;
+        }
+
+        entry.State = RecordingState.WaitingForStream;
+    }
+
+    private static void CompleteRecording(RecordingEntry entry, DateTime now)
+    {
+        entry.State = RecordingState.Completed;
+        entry.RecordingEndedAt = now;
+        if (entry.OutputPath != null && File.Exists(entry.OutputPath))
+        {
+            entry.FileSizeBytes = new FileInfo(entry.OutputPath).Length;
+        }
+    }
+
+    /// <summary>
+    /// Reads the DVR window start (unix seconds in the start= query parameter) from a stream URL.
+    /// </summary>
+    private static DateTime? GetDvrWindowStart(string streamUrl)
+    {
+        if (!Uri.TryCreate(streamUrl, UriKind.Absolute, out var uri))
+        {
+            return null;
+        }
+
+        var start = System.Web.HttpUtility.ParseQueryString(uri.Query)["start"];
+        return long.TryParse(start, NumberStyles.Integer, CultureInfo.InvariantCulture, out var seconds)
+            ? DateTimeOffset.FromUnixTimeSeconds(seconds).UtcDateTime
+            : null;
+    }
+
     private void StartFfmpeg(string recordingId, string inputUrl, string outputPath)
     {
         var process = new Process
@@ -480,13 +587,16 @@ public class RecordingService : IRecordingService, IDisposable
             StartInfo = new ProcessStartInfo
             {
                 FileName = _mediaEncoder.EncoderPath,
-                Arguments = $"-y -i \"{inputUrl}\" -c copy -movflags +faststart \"{outputPath}\"",
+                // MPEG-TS on stdout: it has no header/index to finalise, so the file is playable while it
+                // grows, and we append it ourselves so restarts continue the same file. -copyts keeps the
+                // broadcast timestamps so an appended restart continues the timeline instead of resetting to 0.
+                Arguments = $"-i \"{inputUrl}\" -c copy -copyts -f mpegts pipe:1",
                 UseShellExecute = false,
                 RedirectStandardInput = true,
+                RedirectStandardOutput = true,
                 RedirectStandardError = true,
                 CreateNoWindow = true
-            },
+            }
-            EnableRaisingEvents = true
         };
 
         process.ErrorDataReceived += (_, args) =>
@@ -497,23 +607,49 @@ public class RecordingService : IRecordingService, IDisposable
             }
         };
 
-        process.Exited += (_, _) =>
-        {
-            _logger.LogInformation("ffmpeg process exited for recording {RecordingId} with code {ExitCode}", recordingId, process.ExitCode);
-            _activeProcesses.TryRemove(recordingId, out _);
-        };
-
         process.Start();
         process.BeginErrorReadLine();
 
-        _activeProcesses[recordingId] = process;
+        var active = new ActiveRecording(process);
-        _logger.LogInformation("Started ffmpeg (PID {Pid}) for recording {RecordingId}: {Args}", process.Id, recordingId, process.StartInfo.Arguments);
+        _activeProcesses[recordingId] = active;
+        active.Pump = PumpToFileAsync(recordingId, active, outputPath);
+
+        _logger.LogInformation("Started ffmpeg (PID {Pid}) for recording {RecordingId} -> {OutputPath}: {Args}", process.Id, recordingId, outputPath, process.StartInfo.Arguments);
+    }
+
+    /// <summary>
+    /// Appends ffmpeg's stdout to the recording file. The recording counts as active until
+    /// ffmpeg has exited and all of its output is on disk, so a restart never interleaves writes.
+    /// </summary>
+    private async Task PumpToFileAsync(string recordingId, ActiveRecording active, string outputPath)
+    {
+        try
+        {
+            var output = new FileStream(outputPath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite | FileShare.Delete);
+            await using (output.ConfigureAwait(false))
+            {
+                await active.Process.StandardOutput.BaseStream.CopyToAsync(output).ConfigureAwait(false);
+            }
+
+            await active.Process.WaitForExitAsync().ConfigureAwait(false);
+            _logger.LogInformation("ffmpeg process exited for recording {RecordingId} with code {ExitCode}", recordingId, active.Process.ExitCode);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error writing recording output for {RecordingId}", recordingId);
+        }
+        finally
+        {
+            // Only remove our own entry; a newer process may already be registered
+            _activeProcesses.TryRemove(new KeyValuePair<string, ActiveRecording>(recordingId, active));
+        }
     }
 
     private void StopFfmpeg(string recordingId)
     {
-        if (_activeProcesses.TryRemove(recordingId, out var process))
+        if (_activeProcesses.TryRemove(recordingId, out var active))
         {
+            var process = active.Process;
             try
             {
                 if (!process.HasExited)
@@ -529,6 +665,8 @@ public class RecordingService : IRecordingService, IDisposable
                     }
                 }
 
+                // Let the remaining output reach the file before releasing the process
+                active.Pump?.Wait(TimeSpan.FromSeconds(10));
                 process.Dispose();
             }
             catch (Exception ex)
@@ -578,4 +716,19 @@ public class RecordingService : IRecordingService, IDisposable
 
         _disposed = true;
     }
+
+    /// <summary>
+    /// A running ffmpeg process and the task copying its output to disk.
+    /// </summary>
+    private sealed class ActiveRecording
+    {
+        public ActiveRecording(Process process)
+        {
+            Process = process;
+        }
+
+        public Process Process { get; }
+
+        public Task? Pump { get; set; }
+    }
 }

Jellyfin.Plugin.SRFPlay/Services/StreamProxyService.cs

@@ -132,10 +132,13 @@ public class StreamProxyService : IStreamProxyService
                 !string.IsNullOrEmpty(streamInfo.AuthenticatedUrl));
 
             // Check for stale alias: only look for fresher stream if current token is EXPIRED or EXPIRING SOON
-            // Don't replace a valid token (>5s left) with a new deferred registration
+            // Don't replace a valid token (>5s left) with a new deferred registration.
-            if (!streamInfo.NeedsAuthentication && tokenTimeLeft < 5)
+            // Livestreams with a URN refresh themselves from the API, so never swap them: an unrelated
+            // registration (e.g. from a library refresh) would point the stream at the wrong CDN path.
+            var selfRefreshing = streamInfo.IsLiveStream && !string.IsNullOrEmpty(streamInfo.Urn);
+            if (!streamInfo.NeedsAuthentication && tokenTimeLeft < 5 && !selfRefreshing)
             {
-                var freshStream = FindFreshestStream();
+                var freshStream = FindFreshestStream(streamInfo.Urn);
                 if (freshStream != null && freshStream.Value.Value.NeedsAuthentication)
                 {
                     _logger.LogWarning(
@@ -595,8 +598,9 @@ public class StreamProxyService : IStreamProxyService
     /// <summary>
     /// Finds the freshest (most recently registered) stream that needs authentication or has a valid token.
     /// </summary>
+    /// <param name="urn">When set, only streams for this URN are considered.</param>
     /// <returns>The freshest stream entry, or null if none found.</returns>
-    private KeyValuePair<string, StreamInfo>? FindFreshestStream()
+    private KeyValuePair<string, StreamInfo>? FindFreshestStream(string? urn)
     {
         var now = DateTime.UtcNow;
 
@@ -604,6 +608,11 @@ public class StreamProxyService : IStreamProxyService
         // or have tokens that aren't expired yet
         var candidates = _streamMappings.Where(kvp =>
         {
+            if (!string.IsNullOrEmpty(urn) && !string.Equals(kvp.Value.Urn, urn, StringComparison.OrdinalIgnoreCase))
+            {
+                return false; // Different content
+            }
+
             if (kvp.Value.NeedsAuthentication)
             {
                 return true; // Fresh deferred registration

Jellyfin.Plugin.SRFPlay/Utilities/DisplayTime.cs

@@ -0,0 +1,42 @@
+using System;
+
+namespace Jellyfin.Plugin.SRFPlay.Utilities;
+
+/// <summary>
+/// Converts times into the time zone the plugin writes into text (item names, file names).
+/// SRG sends times with an offset, and DateTime deserialisation turns them into server-local
+/// values, so without this the text follows whatever zone the server happens to run in.
+/// </summary>
+public static class DisplayTime
+{
+    /// <summary>
+    /// Converts a time to the configured display time zone (the server's if none is set).
+    /// </summary>
+    /// <param name="value">The time. Unspecified values are treated as server-local, like deserialised ones.</param>
+    /// <returns>The same instant expressed in the display time zone.</returns>
+    public static DateTime From(DateTime value)
+    {
+        return TimeZoneInfo.ConvertTimeFromUtc(value.ToUniversalTime(), GetZone());
+    }
+
+    /// <summary>
+    /// Gets the current time in the display time zone.
+    /// </summary>
+    /// <returns>The current time in the display time zone.</returns>
+    public static DateTime Now()
+    {
+        return TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, GetZone());
+    }
+
+    private static TimeZoneInfo GetZone()
+    {
+        var id = Plugin.Instance?.Configuration.DisplayTimeZone;
+        if (string.IsNullOrWhiteSpace(id))
+        {
+            return TimeZoneInfo.Local;
+        }
+
+        // An unknown id falls back to the server's zone rather than breaking listings.
+        return TimeZoneInfo.TryFindSystemTimeZoneById(id.Trim(), out var zone) ? zone : TimeZoneInfo.Local;
+    }
+}

manifest-nightly.json

@@ -8,6 +8,78 @@
     "category": "Live TV",
     "imageUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/raw/branch/master/assests/main%20logo.png",
     "versions": [
+      {
+        "version": "1.0.20260925.21912",
+        "changelog": "Nightly build 1.0.20260925.21912 (95ce4ed)",
+        "targetAbi": "12.0.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.20260925.21912.zip",
+        "checksum": "2256a19f4089e3958821124cc06952f3",
+        "timestamp": "2026-09-25T23:30:39Z"
+      },
+      {
+        "version": "1.0.20260925.21911",
+        "changelog": "Nightly build 1.0.20260925.21911 (95ce4ed)",
+        "targetAbi": "10.11.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.20260925.21911.zip",
+        "checksum": "488443d6c721244594be8f1cada52a6f",
+        "timestamp": "2026-09-25T23:30:39Z"
+      },
+      {
+        "version": "1.0.20260925.21909",
+        "changelog": "Nightly build 1.0.20260925.21909 (95ce4ed)",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.20260925.21909.zip",
+        "checksum": "1b1bcaea6e46b3ecf71912fa6d07d985",
+        "timestamp": "2026-09-25T23:30:39Z"
+      },
+      {
+        "version": "1.0.20260924.21612",
+        "changelog": "Nightly build 1.0.20260924.21612 (3c321b4)",
+        "targetAbi": "12.0.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.20260924.21612.zip",
+        "checksum": "146824b350e6f10c0861dea198e5dd51",
+        "timestamp": "2026-09-24T03:01:30Z"
+      },
+      {
+        "version": "1.0.20260924.21611",
+        "changelog": "Nightly build 1.0.20260924.21611 (3c321b4)",
+        "targetAbi": "10.11.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.20260924.21611.zip",
+        "checksum": "e63045bda702234285ee6d2f62034397",
+        "timestamp": "2026-09-24T03:01:30Z"
+      },
+      {
+        "version": "1.0.20260924.21609",
+        "changelog": "Nightly build 1.0.20260924.21609 (3c321b4)",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.20260924.21609.zip",
+        "checksum": "57592a884c09600d11f82702ac5d1805",
+        "timestamp": "2026-09-24T03:01:30Z"
+      },
+      {
+        "version": "1.0.20260924.21212",
+        "changelog": "Nightly build 1.0.20260924.21212 (db9461c)",
+        "targetAbi": "12.0.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.20260924.21212.zip",
+        "checksum": "b497b4f8a9c5822909b6df0ed37b8b3d",
+        "timestamp": "2026-09-24T01:14:34Z"
+      },
+      {
+        "version": "1.0.20260924.21211",
+        "changelog": "Nightly build 1.0.20260924.21211 (db9461c)",
+        "targetAbi": "10.11.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.20260924.21211.zip",
+        "checksum": "e3b98d2db0253dc42c3cc87645bffa0e",
+        "timestamp": "2026-09-24T01:14:34Z"
+      },
+      {
+        "version": "1.0.20260924.21209",
+        "changelog": "Nightly build 1.0.20260924.21209 (db9461c)",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/latest/srfplay_1.0.20260924.21209.zip",
+        "checksum": "1f4b3fe079d32a08968d7dfb99dc813f",
+        "timestamp": "2026-09-24T01:14:34Z"
+      },
       {
         "version": "1.0.20260908.201",
         "changelog": "Nightly build 1.0.20260908.201 (d0d5d06)",

manifest.json

@@ -8,6 +8,54 @@
     "category": "Live TV",
     "imageUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/raw/branch/master/assests/main%20logo.png",
     "versions": [
+      {
+        "version": "1.3.0.12",
+        "changelog": "Release 1.3.0",
+        "targetAbi": "12.0.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.3.0/srfplay_1.3.0.12.zip",
+        "checksum": "117970ad31cb34b6cccaf90262c51b4b",
+        "timestamp": "2026-09-25T23:32:44Z"
+      },
+      {
+        "version": "1.3.0.11",
+        "changelog": "Release 1.3.0",
+        "targetAbi": "10.11.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.3.0/srfplay_1.3.0.11.zip",
+        "checksum": "2136a102d793b64561656d0c0b04dd6f",
+        "timestamp": "2026-09-25T23:32:44Z"
+      },
+      {
+        "version": "1.3.0.9",
+        "changelog": "Release 1.3.0",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.3.0/srfplay_1.3.0.9.zip",
+        "checksum": "47008ac9ba658868bb8fc3f56c8c7e02",
+        "timestamp": "2026-09-25T23:32:44Z"
+      },
+      {
+        "version": "1.2.1.12",
+        "changelog": "Release 1.2.1",
+        "targetAbi": "12.0.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.2.1/srfplay_1.2.1.12.zip",
+        "checksum": "e7fe29977ed387f5f324b58aa40d8ebb",
+        "timestamp": "2026-09-24T01:16:46Z"
+      },
+      {
+        "version": "1.2.1.11",
+        "changelog": "Release 1.2.1",
+        "targetAbi": "10.11.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.2.1/srfplay_1.2.1.11.zip",
+        "checksum": "f69293b34c2e0e5fc5f2f2117ffb3ded",
+        "timestamp": "2026-09-24T01:16:46Z"
+      },
+      {
+        "version": "1.2.1.9",
+        "changelog": "Release 1.2.1",
+        "targetAbi": "10.9.0.0",
+        "sourceUrl": "https://gitea.tourolle.paris/dtourolle/jellyfin-srfPlay/releases/download/v1.2.1/srfplay_1.2.1.9.zip",
+        "checksum": "f18230d45e510cf60dce3badcd3f29a1",
+        "timestamp": "2026-09-24T01:16:46Z"
+      },
       {
         "version": "1.1.2",
         "changelog": "Release 1.1.2",

test-image.sh

@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+# Build the SRF Play plugin from the local checkout, bake it into a stock
+# Jellyfin image, and run it on http://localhost:8096.
+#
+#   ./test-image.sh          build + run
+#   ./test-image.sh build    build image only (no run)
+#
+# JELLYFIN_TAG picks the Jellyfin image (default 12) and, with it, the matching
+# plugin build (see the TargetFrameworks comment in the plugin csproj):
+#
+#   JELLYFIN_TAG=10.11.0 ./test-image.sh
+set -euo pipefail
+
+cd "$(dirname "$0")"
+
+JELLYFIN_TAG="${JELLYFIN_TAG:-12}"
+PLUGIN_DIR=".test-plugin/SRFPlay"
+IMAGE="srfplay-test:${JELLYFIN_TAG}"
+
+case "$JELLYFIN_TAG" in
+    10.9*|10.10*) FRAMEWORK="net8.0";  ABI="10.9.0.0" ;;
+    10.11*)       FRAMEWORK="net9.0";  ABI="10.11.0.0" ;;
+    *)            FRAMEWORK="net10.0"; ABI="12.0.0.0" ;;
+esac
+
+echo ">> Publishing plugin for Jellyfin ${JELLYFIN_TAG} (${FRAMEWORK}, host build, warm cache)..."
+rm -rf .test-plugin
+dotnet publish Jellyfin.Plugin.SRFPlay/Jellyfin.Plugin.SRFPlay.csproj \
+    --configuration Release --framework "$FRAMEWORK" --no-self-contained -o /tmp/srfplay-publish >/dev/null
+
+mkdir -p "$PLUGIN_DIR"
+cp /tmp/srfplay-publish/Jellyfin.Plugin.SRFPlay.dll "$PLUGIN_DIR/"
+
+# Generate the meta.json Jellyfin needs to load the plugin, from build.yaml.
+# targetAbi follows the framework chosen above rather than build.yaml.
+GUID=$(grep -E '^guid:'      build.yaml | sed -E 's/^guid:[[:space:]]*"?([^"]+)"?.*/\1/')
+VERSION=$(grep -E '^version:' build.yaml | sed -E 's/^version:[[:space:]]*"?([^"]+)"?.*/\1/')
+
+cat > "$PLUGIN_DIR/meta.json" <<EOF
+{
+  "guid": "$GUID",
+  "name": "SRF Play",
+  "version": "$VERSION",
+  "targetAbi": "$ABI",
+  "owner": "dtourolle",
+  "overview": "SRF Play plugin for Jellyfin (test build)",
+  "description": "Local test build of the SRF Play plugin.",
+  "category": "Live TV",
+  "status": "Active",
+  "autoUpdate": false
+}
+EOF
+
+echo ">> Building image $IMAGE (stock Jellyfin + plugin COPY)..."
+docker build -f Dockerfile.test --build-arg JELLYFIN_TAG="$JELLYFIN_TAG" -t "$IMAGE" .
+
+if [ "${1:-run}" = "build" ]; then
+    echo ">> Built $IMAGE. Run with: docker run --rm -p 8096:8096 $IMAGE"
+    exit 0
+fi
+
+# --- Optional: route the container's egress via a LAN gateway ----------------
+# Set DOCKER_GATEWAY to a LAN gateway IP (e.g. the Swiss VPN box 192.168.1.52)
+# to send this container's outbound traffic through it. Needs sudo once to add
+# host policy-route + masquerade; both are removed automatically on exit.
+#
+#   DOCKER_GATEWAY=192.168.1.52 ./test-image.sh
+#
+# When unset, the container uses Docker's normal default route (your ISP).
+
+TEST_NET="srfplay-testnet"
+TEST_SUBNET="172.31.250.0/24"
+TEST_TABLE="250"            # dedicated rt table for this subnet
+# The uplink is the interface that actually reaches the gateway (the LAN NIC,
+# e.g. wlan0) — NOT the host default route, which a VPN killswitch may point
+# at the tunnel. Derive it from the route to DOCKER_GATEWAY when set.
+if [ -n "${DOCKER_GATEWAY:-}" ]; then
+    UPLINK_IF="$(ip route get "$DOCKER_GATEWAY" 2>/dev/null | grep -oE 'dev [^ ]+' | awk '{print $2}')"
+fi
+
+cleanup() {
+    echo ">> Cleaning up..."
+    docker rm -f srfplay-test-run >/dev/null 2>&1 || true
+    if [ -n "${DOCKER_GATEWAY:-}" ]; then
+        sudo ip rule del from "$TEST_SUBNET" table "$TEST_TABLE" 2>/dev/null || true
+        sudo ip route flush table "$TEST_TABLE" 2>/dev/null || true
+        sudo iptables -t nat -D POSTROUTING -s "$TEST_SUBNET" -o "$UPLINK_IF" -j MASQUERADE 2>/dev/null || true
+    fi
+    docker network rm "$TEST_NET" >/dev/null 2>&1 || true
+}
+trap cleanup EXIT INT TERM
+
+docker network rm "$TEST_NET" >/dev/null 2>&1 || true
+docker network create --subnet "$TEST_SUBNET" "$TEST_NET" >/dev/null
+
+if [ -n "${DOCKER_GATEWAY:-}" ]; then
+    echo ">> Routing container egress via gateway $DOCKER_GATEWAY (uplink $UPLINK_IF)..."
+    echo "   (sudo needed once to install host routes; removed on exit)"
+    sudo ip route replace default via "$DOCKER_GATEWAY" dev "$UPLINK_IF" table "$TEST_TABLE"
+    sudo ip rule add from "$TEST_SUBNET" table "$TEST_TABLE" 2>/dev/null || true
+    sudo iptables -t nat -C POSTROUTING -s "$TEST_SUBNET" -o "$UPLINK_IF" -j MASQUERADE 2>/dev/null \
+        || sudo iptables -t nat -A POSTROUTING -s "$TEST_SUBNET" -o "$UPLINK_IF" -j MASQUERADE
+fi
+
+echo ">> Starting Jellyfin on http://localhost:8096 (Ctrl-C to stop)..."
+docker run --rm --name srfplay-test-run --network "$TEST_NET" -p 8096:8096 "$IMAGE"