TASK 47 take four: alert ticker visible in the preview + 3 display methods

The creator confirmed the clip fix ("the video plays now"), then asked where the
scrolling text was — it was invisible, for a structural reason. AlertTickerFrame
existed only as a frame-pump callback blitted into the OUTPUT; PreviewPane.xaml had
no element for it, because the strip is master-width and global, not a Source, so it
cannot ride a per-element Image. Nothing was wrong in the renderer: there was no
consumer in the preview. Same class of defect as the missing IsAlertBox trigger, one
layer up (MyMistakes RULE 5/6).

- tickerPreviewSink on AlertOverlayLayer, published from RefreshAlertPreviews() so it
  is always the UI thread; MainViewModel.AlertTicker writes it into one reused
  WriteableBitmap bound to a new global AlertTickerElement, mirroring SocialBarElement.
- Source.AlertDisplayMethod + panel "Display" selector: TickerScroll / Flash / Solid.
  Flash pulses 0.5s on / 0.5s off for the whole alert; Solid is centred and still.
- The marquee was also unreadable: a fixed 140px/s took ~17s per pass, so a 10s alert
  showed the text once, entering from the right and never crossing. Paced in reads per
  alert instead (TickerReadsPerAlert = 3 inside the alert's own length, speed derived
  from it) — never px/s. Research (websearch: how do OBS/Streamlabs/StreamElements
  alert boxes present announcement timing?) settled the unit: Streamlabs exposes "Alert
  Duration: choose how long your alert stays on your stream" and "Text Delay", never a
  scroll-speed slider (https://support.streamlabs.com/hc/en-us/articles/52499995174299-Setting-up-Your-Streamlabs-Alerts).
  Run is phase-started half a frame in so the first frame isn't blank.
- Persistence: AlertDisplayMethod INTEGER NOT NULL DEFAULT 0 via the idempotent
  table_info migration, appended LAST in the SELECT because the Source reader is
  positional (GetInt32(32..34)) — a mid-list insert would silently shift a neighbour.

Tests: 15 new facts (suite 339/339). RealApp STA host: the pane draws the strip and
collapses at alert end; the layer publishes a real 1920x48 frame for all three methods
and nothing when the ticker is off; three passes counted in 10s by the pill's leading
edge resetting (a seamless marquee never blanks, so an empty frame cannot count a pass);
Solid byte-identical at every moment; Flash on for half of each second; the panel shows
and writes back the choice; the DB round-trips all three alert fields together.

Incidental finding: a bound ItemsSource ComboBox in LeftPanel.xaml broke
LayerReorderPersistenceTests.RealMouseDrag (that test injects PHYSICAL mouse input, so a
load-time re-measure moves the rows out from under the cursor). Rewritten as inline
ComboBoxItems, the shape the chat Font selector already uses in that panel. Recorded as
MyMistakes RULE (8).

Services/AlertOverlayLayer.cs

@@ -52,6 +52,7 @@ public sealed class AlertOverlayLayer : IDisposable
     private readonly Func<string, int, int, IAlertClipDecoder>? _clipDecoderFactory;
     private readonly Func<Source, string?>? _clipPathResolver;
     private readonly Action<AudioSample>? _audioSink;
+    private readonly Action<VideoFrame?>? _tickerPreviewSink;
     private readonly Queue<ChatMessage> _queue = new();
     private readonly DispatcherTimer? _ticker;
 
@@ -66,6 +67,7 @@ public sealed class AlertOverlayLayer : IDisposable
     private bool _clipSawFrame;
     private bool _clipAudioHeard;
     private string? _tickerText;
+    private AlertDisplayMethod _tickerMethod = AlertDisplayMethod.TickerScroll;
     private double _elapsed;
     private IEnumerable<Scene>? _scenes;
 
@@ -79,12 +81,14 @@ public sealed class AlertOverlayLayer : IDisposable
         AlertRenderer renderer,
         Func<string, int, int, IAlertClipDecoder>? clipDecoderFactory = null,
         Func<Source, string?>? clipPathResolver = null,
-        Action<AudioSample>? audioSink = null)
+        Action<AudioSample>? audioSink = null,
+        Action<VideoFrame?>? tickerPreviewSink = null)
     {
         _renderer = renderer;
         _clipDecoderFactory = clipDecoderFactory;
         _clipPathResolver = clipPathResolver;
         _audioSink = audioSink;
+        _tickerPreviewSink = tickerPreviewSink;
         if (Application.Current != null)
         {
             _ticker = new DispatcherTimer { Interval = TickInterval };
@@ -234,19 +238,32 @@ public sealed class AlertOverlayLayer : IDisposable
     }
 
     /// <summary>The global ticker strip for the stream output (top edge, full
-    /// master width): a marquee of "viewer — event" while an alert is playing
-    /// and the config has the ticker on, else null. Pure byte-math per call so
-    /// the frame pump can read it on any thread (the text strip is rasterized
-    /// once on the UI thread and cached).</summary>
+    /// master width) and the preview pane: a marquee, a pulse or a static pill
+    /// naming the event while an alert plays, else null. Pure byte-math per call so
+    /// the frame pump can read it on any thread (the text strip is rasterized once
+    /// on the UI thread and cached).</summary>
     public VideoFrame? AlertTickerFrame
     {
         get
         {
             if (_current == null || string.IsNullOrWhiteSpace(_tickerText)) return null;
-            return AlertTickerRenderer.Render(_tickerText!, _elapsed);
+            return AlertTickerRenderer.Render(_tickerText!, _elapsed, _tickerMethod, AlertSeconds());
         }
     }
 
+    /// <summary>How many times the marquee must cross the frame per alert, so the
+    /// announcement is actually readable inside a 10s clip (2026-09-26: the old
+    /// fixed 140px/s took ~17s per pass, so a 10s alert showed it barely once).</summary>
+    internal const int TickerReadsPerAlert = 3;
+
+    /// <summary>Assumed alert length for the marquee rhythm. The clip's real length
+    /// isn't known until it EOFs, and the shipped default clip is 10s — the number
+    /// the creator's "three reads" target is stated against.</summary>
+    internal const double AssumedAlertSeconds = 10.0;
+
+    private double AlertSeconds() => _clip != null ? AssumedAlertSeconds : DurationOf(_current!);
+
+
     private VideoFrame? RenderClipFrame(Source alertBox)
     {
         var frame = _latestClipFrame;
@@ -289,7 +306,10 @@ public sealed class AlertOverlayLayer : IDisposable
             .FirstOrDefault(s => s.Type == SourceType.AlertBox);
         _currentBox = box;
         if (box != null && box.AlertShowTicker)
+        {
             _tickerText = ComposeTicker(_current);
+            _tickerMethod = box.AlertDisplayMethod;
+        }
 
         if (box == null || _clipDecoderFactory == null) return;
         var path = _clipPathResolver?.Invoke(box);
@@ -478,6 +498,12 @@ public sealed class AlertOverlayLayer : IDisposable
 
     private void RefreshAlertPreviews()
     {
+        // The announcement strip is a GLOBAL 1920px overlay, not a per-box frame, so
+        // it gets its own sink: until this existed the strip went only to the frame
+        // pump and was therefore invisible in the preview pane the creator watches
+        // (2026-09-26 — "I do not see the scrolling text").
+        _tickerPreviewSink?.Invoke(AlertTickerFrame);
+
         if (_scenes == null) return;
         foreach (var alertBox in _scenes.SelectMany(s => s.Elements).OfType<Source>()
                      .Where(s => s.Type == SourceType.AlertBox))

Services/Compositor/AlertTickerRenderer.cs

@@ -4,6 +4,7 @@ using System.Windows;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
 using System.Windows.Threading;
+using ytLive.Models;
 
 namespace ytLive.Services.Compositor;
 
@@ -26,34 +27,64 @@ public static class AlertTickerRenderer
     /// <summary>Strip height (pill + vertical padding).</summary>
     public const int Height = 48;
 
-    private const int PixelsPerSecond = 140;
     private const int RepeatGap = 120;
     private const int CacheLimit = 48;
 
+    /// <summary>How long each blink half lasts in <see cref="AlertDisplayMethod.Flash"/>
+    /// (0.5s on, 0.5s off — a 1Hz pulse for the whole alert).</summary>
+    public const double FlashHalfSeconds = 0.5;
+
     private static readonly object Gate = new();
     private static readonly Dictionary<string, VideoFrame> StripCache = new();
 
-    /// <summary>A marquee frame of <paramref name="text"/> scrolled
-    /// <paramref name="elapsedSeconds"/> into its loop, or null for empty text.
-    /// Thread-safe: reads the cached raster and does row copies only.</summary>
-    public static VideoFrame? Render(string? text, double elapsedSeconds)
+    /// <summary>A frame of <paramref name="text"/> presented per
+    /// <paramref name="method"/> at <paramref name="elapsedSeconds"/> into the alert,
+    /// or null when there is nothing to show (no text, or a Flash in its off half).
+    /// Thread-safe: reads the cached raster and does row copies only.
+    /// <para><see cref="AlertDisplayMethod.TickerScroll"/> paces itself from
+    /// <paramref name="readsPerAlert"/> over <paramref name="alertSeconds"/> rather
+    /// than a fixed pixels-per-second: the old constant (140px/s ≈ a 17s pass) meant
+    /// a 10s alert showed the text barely once, entering from the right and never
+    /// crossing. The creator's target is three readable passes per alert.</para></summary>
+    public static VideoFrame? Render(string? text, double elapsedSeconds,
+        AlertDisplayMethod method = AlertDisplayMethod.TickerScroll,
+        double alertSeconds = 0.0, int readsPerAlert = 3)
     {
         if (string.IsNullOrWhiteSpace(text)) return null;
         var strip = GetStrip(text!);
         if (strip == null) return null;
 
-        var sw = strip.Width;
-        var cycle = Width + sw + RepeatGap;
-        var pos = (int)(elapsedSeconds * PixelsPerSecond) % cycle;
-        var x = Width - pos;
+        if (method == AlertDisplayMethod.Flash
+            && elapsedSeconds % (FlashHalfSeconds * 2) >= FlashHalfSeconds)
+            return null; // off half of the pulse
+
+        var x = method == AlertDisplayMethod.TickerScroll
+            ? ScrollX(strip.Width, elapsedSeconds, alertSeconds, readsPerAlert)
+            : (Width - strip.Width) / 2; // Solid + Flash: centred, still
 
         var pixels = new byte[Width * Height * 4];
         CopyStrip(pixels, strip, x);
-        if (x < 0)
+        if (method == AlertDisplayMethod.TickerScroll && x + strip.Width <= 0)
             CopyStrip(pixels, strip, x + Width + RepeatGap); // wrapped tail enters from the right
         return new VideoFrame(Width, Height, pixels);
     }
 
+    /// <summary>Left edge of the pill for a marquee that must complete
+    /// <paramref name="readsPerAlert"/> passes in <paramref name="alertSeconds"/>:
+    /// one pass (off the right edge, across, out of sight) takes that long.
+    /// <para>The run is phase-started half a frame in, so the very first frame of an
+    /// alert already shows the announcement instead of a blank strip sitting exactly
+    /// off the right edge.</para></summary>
+    private static int ScrollX(int stripWidth, double elapsedSeconds, double alertSeconds, int readsPerAlert)
+    {
+        var cycle = Width + stripWidth + RepeatGap;
+        var pass = Math.Max(0.5, alertSeconds) / Math.Max(1, readsPerAlert);
+        var speed = cycle / pass;
+        var pos = (Width / 2 + (int)(elapsedSeconds * speed)) % cycle;
+        return Width - pos;
+    }
+
+
     private static void CopyStrip(byte[] dst, VideoFrame strip, int dstX)
     {
         if (dstX >= Width || dstX + strip.Width <= 0) return;

Services/LayoutStore.Load.cs

@@ -100,7 +100,8 @@ public partial class LayoutStore : IDisposable
                        ChatFontSize, ChatFontColor, ChatBackgroundColor, ChatMaxMessages,
                        ChatShowTimestamps, ChatShowBadges, ChatMemberColor, ChatSuperChatColor,
                        WebUri, MediaPath, MediaIsLooping, MediaVolume, MediaPlaybackState,
-                       AlertVideoAssetId, AlertVideoPath, AlertUseDefaultVideo, AlertShowTicker, AlertVideoVolume, SortOrder
+                       AlertVideoAssetId, AlertVideoPath, AlertUseDefaultVideo, AlertShowTicker, AlertVideoVolume, SortOrder,
+                       AlertDisplayMethod
                 FROM Source ORDER BY SortOrder
                 """;
             using var reader = cmd.ExecuteReader();
@@ -151,6 +152,7 @@ public partial class LayoutStore : IDisposable
                     AlertUseDefaultVideo = reader.IsDBNull(32) ? true : reader.GetInt32(32) != 0,
                     AlertShowTicker = reader.IsDBNull(33) ? true : reader.GetInt32(33) != 0,
                     AlertVideoVolume = reader.IsDBNull(34) ? 1.0 : reader.GetDouble(34),
+                    AlertDisplayMethod = reader.IsDBNull(36) ? AlertDisplayMethod.TickerScroll : (AlertDisplayMethod)reader.GetInt32(36),
                 };
                 if (!sourcesByScene.TryGetValue(sceneId, out var list))
                     sourcesByScene[sceneId] = list = new List<(Source, int)>();

Services/LayoutStore.Migrations.cs

@@ -169,6 +169,13 @@ public partial class LayoutStore : IDisposable
             cmd.ExecuteNonQuery();
         }
 
+        if (!columns.Contains("AlertDisplayMethod"))
+        {
+            using var cmd = _connection.CreateCommand();
+            cmd.CommandText = "ALTER TABLE Source ADD COLUMN AlertDisplayMethod INTEGER NOT NULL DEFAULT 0;";
+            cmd.ExecuteNonQuery();
+        }
+
         if (!columns.Contains("IsMirrored"))
         {
             using var cmd = _connection.CreateCommand();

Services/LayoutStore.Save.cs

@@ -89,14 +89,16 @@ public partial class LayoutStore : IDisposable
                                     ChatFontSize, ChatFontColor, ChatBackgroundColor, ChatMaxMessages,
                                     ChatShowTimestamps, ChatShowBadges, ChatMemberColor, ChatSuperChatColor,
                                     WebUri, MediaPath, MediaIsLooping, MediaVolume, MediaPlaybackState,
-                                    AlertVideoAssetId, AlertVideoPath, AlertUseDefaultVideo, AlertShowTicker, AlertVideoVolume)
+                                    AlertVideoAssetId, AlertVideoPath, AlertUseDefaultVideo, AlertShowTicker, AlertVideoVolume,
+                                    AlertDisplayMethod)
                 VALUES ($id, $sceneId, $assetId, $type, $name, $isEnabled,
                         $x, $y, $w, $h, $opacity, $monitor,
                         $clip, $mirrored, $isBackground, $captureKey, $showDesktop, $sort,
                         $chatFontSize, $chatFontColor, $chatBgColor, $chatMaxMsgs,
                         $chatTimestamps, $chatBadges, $chatMemberColor, $chatSuperChatColor,
                         $webUri, $mediaPath, $mediaIsLooping, $mediaVolume, $mediaPlaybackState,
-                        $alertVideoAssetId, $alertVideoPath, $alertUseDefaultVideo, $alertShowTicker, $alertVideoVolume)
+                        $alertVideoAssetId, $alertVideoPath, $alertUseDefaultVideo, $alertShowTicker, $alertVideoVolume,
+                        $alertDisplayMethod)
                 """;
             cmd.Transaction = tx;
             var idP = cmd.Parameters.Add("$id", SqliteType.Text);
@@ -135,6 +137,7 @@ public partial class LayoutStore : IDisposable
             var alertUseDefaultVideoP = cmd.Parameters.Add("$alertUseDefaultVideo", SqliteType.Integer);
             var alertShowTickerP = cmd.Parameters.Add("$alertShowTicker", SqliteType.Integer);
             var alertVideoVolumeP = cmd.Parameters.Add("$alertVideoVolume", SqliteType.Real);
+            var alertDisplayMethodP = cmd.Parameters.Add("$alertDisplayMethod", SqliteType.Integer);
 
             // Source and WebcamSceneConfig share ONE z-order space per scene:
             // each element gets its index within scene.Elements regardless of
@@ -182,6 +185,7 @@ public partial class LayoutStore : IDisposable
                     alertUseDefaultVideoP.Value = source.AlertUseDefaultVideo ? 1 : 0;
                     alertShowTickerP.Value = source.AlertShowTicker ? 1 : 0;
                     alertVideoVolumeP.Value = source.AlertVideoVolume;
+                    alertDisplayMethodP.Value = (int)source.AlertDisplayMethod;
                     cmd.ExecuteNonQuery();
                 }
             }