alert ticker: draw it inside the Stream Alerts box, not as a top-edge bar

Creator 2026-09-26: "the ticker should appear over the stream alerts video, not over
the entire preview window". It was a GLOBAL 1920x48 bar blitted last at a hardcoded
(0, 0) -- it covered the whole preview width, not the alert video.

The strip is now rendered at the alert box's own size and the box's origin travels on
the frame in a new VideoFrame.Placement ((int X, int Y)?). OriginX/OriginY default to
0 when Placement is null, so every full-canvas overlay (the branding flash) is
unaffected. Every ticker blit site now reads tickerFrame.OriginX/OriginY instead of a
literal 0, 0 -- SceneCompositor x2 and FramePump's static-bake Overlay path -- and
PreviewPane.xaml's AlertTickerElement binds the same rect (AlertTickerLeft/Top/
Width/Height), so the preview cannot drift from the recording the creator is judging.

Why the position rides on the frame rather than in a full-canvas frame: a 1920x1080
overlay is 8.3MB of large-object-heap garbage per tick, ~2.5GB churned over one 10s
alert at 30fps. A box-sized strip is ~370KB. The branding flash does render
full-canvas but RECYCLES one 8MB buffer and bumps Epoch, so it never allocates per
frame; the ticker allocates per call, so it has to stay small.

Also fixed: CopyStrip now clips ROWS to the target height. The pill rasterises at its
natural 48px, so an alert box shorter than that would have written past the end of the
target buffer once the strip became box-sized.

No alert box in the scene now means no ticker at all -- there is no global position
left for it, and this is the guard against the old bar quietly coming back.

Tests (3 new facts, 27 in the file):
  ComposedOutput_PutsTheTickerInsideTheAlertBox_NotAtTheTopEdge -- renders through
    the real SceneCompositor and asserts the pixels land at (620, 430) and NOT at the
    top-left corner. The creator is judging compositing from local recordings, so the
    OUTPUT side is the side that needed proving.
  ASceneWithNoAlertBox_PublishesNoTicker
  ABoxShorterThanTheStrip_ClipsRowsInsteadOfOverrunning
Updated AlertLayer_PublishesARealTickerFrameToThePreviewSink, which asserted the old
1920 width from a box with no geometry (defaulted to 1px); it now uses the product's
own default box (680x200 at 620,430, MainViewModel.Sources.cs:54-57) and pins the
frame size and origin.

Full suite 367/367.

Services/AlertOverlayLayer.cs

@@ -237,17 +237,38 @@ public sealed class AlertOverlayLayer : IDisposable
         return RenderCore(alertBox, width, height, key, _contentVersion);
     }
 
-    /// <summary>The global ticker strip for the stream output (top edge, full
-    /// 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>
+    /// <summary>The ticker strip as the alert box shows it: 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).
+    /// <para><b>Creator ruling 2026-09-26:</b> the strip is composited INSIDE the
+    /// Stream Alerts box, not as a full-width bar at the top edge of the frame — "the
+    /// ticker should appear over the stream alerts video, not over the entire preview
+    /// window". So the frame is rendered at the box's own size and carries the box's
+    /// origin on <see cref="VideoFrame.Placement"/>; every blit site reads
+    /// <see cref="VideoFrame.OriginX"/>/<see cref="VideoFrame.OriginY"/> instead of
+    /// a hardcoded 0. <b>No alert box in the scene means no ticker at all</b> — there
+    /// is no longer a global position for it to live in.</para></summary>
     public VideoFrame? AlertTickerFrame
     {
         get
         {
             if (_current == null || string.IsNullOrWhiteSpace(_tickerText)) return null;
-            return AlertTickerRenderer.Render(_tickerText!, _elapsed, _tickerMethod, AlertSeconds());
+            var box = _currentBox;
+            if (box == null) return null;
+
+            var w = (int)Math.Max(1, Math.Round(box.Width));
+            var h = (int)Math.Max(1, Math.Min(
+                Math.Round(box.Height), AlertTickerRenderer.Height));
+            var frame = AlertTickerRenderer.Render(
+                _tickerText!, _elapsed, _tickerMethod, AlertSeconds(),
+                TickerReadsPerAlert, w, h);
+            return frame == null
+                ? null
+                : new VideoFrame(frame.Width, frame.Height, frame.BgraPixels)
+                {
+                    Placement = ((int)Math.Round(box.X), (int)Math.Round(box.Y)),
+                };
         }
     }
 

Services/Compositor/AlertTickerRenderer.cs

@@ -45,12 +45,19 @@ public static class AlertTickerRenderer
     /// <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>
+    /// crossing. The creator's target is three readable passes per alert.</para>
+    /// <para><paramref name="width"/>/<paramref name="height"/> default to the
+    /// full-master strip. They are parameters because the ticker now renders INTO the
+    /// Stream Alerts box (creator ruling 2026-09-26) and therefore has to be the box's
+    /// size: a 1920-wide strip clipped to an 800px box would hide the announcement
+    /// off the right edge for most of its pass, which is the opposite of readable.</para></summary>
     public static VideoFrame? Render(string? text, double elapsedSeconds,
         AlertDisplayMethod method = AlertDisplayMethod.TickerScroll,
-        double alertSeconds = 0.0, int readsPerAlert = 3)
+        double alertSeconds = 0.0, int readsPerAlert = 3,
+        int width = Width, int height = Height)
     {
         if (string.IsNullOrWhiteSpace(text)) return null;
+        if (width <= 0 || height <= 0) return null;
         var strip = GetStrip(text!);
         if (strip == null) return null;
 
@@ -59,14 +66,14 @@ public static class AlertTickerRenderer
             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
+            ? ScrollX(strip.Width, width, elapsedSeconds, alertSeconds, readsPerAlert)
+            : (width - strip.Width) / 2; // Solid + Flash: centred, still
 
-        var pixels = new byte[Width * Height * 4];
-        CopyStrip(pixels, strip, x);
+        var pixels = new byte[width * height * 4];
+        CopyStrip(pixels, width, height, strip, x);
         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);
+            CopyStrip(pixels, width, height, strip, x + width + RepeatGap); // wrapped tail enters
+        return new VideoFrame(width, height, pixels);
     }
 
     /// <summary>Left edge of the pill for a marquee that must complete
@@ -75,26 +82,31 @@ public static class AlertTickerRenderer
     /// <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)
+    private static int ScrollX(int stripWidth, int width, double elapsedSeconds,
+        double alertSeconds, int readsPerAlert)
     {
-        var cycle = Width + stripWidth + RepeatGap;
+        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;
+        var pos = (width / 2 + (int)(elapsedSeconds * speed)) % cycle;
+        return width - pos;
     }
 
 
-    private static void CopyStrip(byte[] dst, VideoFrame strip, int dstX)
+    private static void CopyStrip(byte[] dst, int dstW, int dstH, VideoFrame strip, int dstX)
     {
-        if (dstX >= Width || dstX + strip.Width <= 0) return;
+        if (dstX >= dstW || dstX + strip.Width <= 0) return;
         var x0 = Math.Max(0, dstX);
-        var x1 = Math.Min(Width, dstX + strip.Width);
+        var x1 = Math.Min(dstW, dstX + strip.Width);
         var sx0 = x0 - dstX;
         var copyBytes = (x1 - x0) * 4;
         var sw = strip.Width;
-        for (var y = 0; y < strip.Height; y++)
-            Buffer.BlockCopy(strip.BgraPixels, (y * sw + sx0) * 4, dst, (y * Width + x0) * 4, copyBytes);
+        // The strip is rasterised at its natural 48px; the target box can be shorter,
+        // and copying strip.Height rows into a shorter dst would run off the end of the
+        // array. Clip the rows, not the buffer.
+        var rows = Math.Min(strip.Height, dstH);
+        for (var y = 0; y < rows; y++)
+            Buffer.BlockCopy(strip.BgraPixels, (y * sw + sx0) * 4, dst, (y * dstW + x0) * 4, copyBytes);
     }
 
     private static VideoFrame? GetStrip(string text)

Services/Compositor/SceneCompositor.cs

@@ -37,8 +37,10 @@ public sealed class SceneCompositor
     /// front): live background (the scene's <c>IsBackground</c> source) → background image →
     /// visible elements (z-order = <c>Elements</c> order, mirroring the XAML DataTemplate) →
     /// branding flash → social bar (a global overlay; spans the master width at
-    /// <paramref name="socialBarTop"/>) → stream-alert ticker (a global overlay pinned to
-    /// the very top, TASK 47). Transparent regions read opaque black.
+    /// <paramref name="socialBarTop"/>) → stream-alert ticker (drawn INSIDE the Stream
+    /// Alerts box, at the origin the frame carries on <see cref="VideoFrame.Placement"/>;
+    /// creator ruling 2026-09-26 — it used to be a global bar pinned to the very top).
+    /// Transparent regions read opaque black.
     /// </summary>
     public VideoFrame Render(
         Scene scene,
@@ -140,7 +142,7 @@ public sealed class SceneCompositor
             BlitOverlay(buffer, cropW, cropH, options, socialBarFrame, 0, socialBarTop);
 
         if (tickerFrame != null && tickerFrame.Width > 0 && tickerFrame.Height > 0)
-            BlitOverlay(buffer, cropW, cropH, options, tickerFrame, 0, 0);
+            BlitOverlay(buffer, cropW, cropH, options, tickerFrame, tickerFrame.OriginX, tickerFrame.OriginY);
 
         return StretchMath.BilinearScale(
             new VideoFrame(cropW, cropH, buffer), options.OutputWidth, options.OutputHeight);
@@ -258,7 +260,7 @@ public sealed class SceneCompositor
         }
 
         if (tickerFrame != null && tickerFrame.Width > 0 && tickerFrame.Height > 0)
-            BlitOverlay(buffer, cropW, cropH, options, tickerFrame, 0, 0);
+            BlitOverlay(buffer, cropW, cropH, options, tickerFrame, tickerFrame.OriginX, tickerFrame.OriginY);
 
         return StretchMath.BilinearScale(new VideoFrame(cropW, cropH, buffer), options.OutputWidth, options.OutputHeight);
     }

Services/Encoder/FramePump.cs

@@ -601,7 +601,7 @@ public sealed class FramePump : IDisposable
                 {
                     var withOverlays = baked;
                     if (flashFrame != null) withOverlays = SceneCompositor.Overlay(withOverlays, options, flashFrame, 0, 0);
-                    if (tickerFrame != null) withOverlays = SceneCompositor.Overlay(withOverlays, options, tickerFrame, 0, 0);
+                    if (tickerFrame != null) withOverlays = SceneCompositor.Overlay(withOverlays, options, tickerFrame, tickerFrame.OriginX, tickerFrame.OriginY);
                     if (socialBarFrame != null) withOverlays = SceneCompositor.Overlay(withOverlays, options, socialBarFrame, socialBarTop, 0);
                     baked = withOverlays;
                 }

Services/VideoFrame.cs

@@ -34,6 +34,22 @@ public sealed class VideoFrame
     /// reveal layers beneath — the crop defines the actual content region.</summary>
     public (int X, int Y, int W, int H)? CropBounds { get; init; }
 
+    /// <summary>Where a SMALLER-than-canvas overlay composites, in master pixels
+    /// (creator ruling 2026-09-26: the alert ticker draws INSIDE the Stream Alerts video
+    /// box, not as a full-width strip pinned to the top edge). <c>null</c> — the default
+    /// — means the canvas origin, which is what every full-canvas overlay wants.
+    /// <para>This is deliberately NOT a full-canvas frame: at 30–60fps a 1920×1080
+    /// overlay is 8.3MB of large-object-heap garbage per tick, and a 10s alert would
+    /// churn ~2.5GB. A box-sized strip is ~370KB, so the position travels on the frame
+    /// instead of in a 1920-wide transparent margin.</para></summary>
+    public (int X, int Y)? Placement { get; init; }
+
+    /// <summary>Composite origin X: <see cref="Placement"/> if set, else 0.</summary>
+    public int OriginX => Placement?.X ?? 0;
+
+    /// <summary>Composite origin Y: <see cref="Placement"/> if set, else 0.</summary>
+    public int OriginY => Placement?.Y ?? 0;
+
     public VideoFrame(int width, int height, byte[] bgraPixels)
     {
         Width = width;