kryten-webqueue 0.15.1__tar.gz → 0.15.2__tar.gz

{kryten_webqueue-0.15.1 → kryten_webqueue-0.15.2}/CHANGELOG.md

@@ -6,6 +6,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ## [Unreleased]
 
+## [0.15.2] — 2026-06-17
+
+### Fixed
+
+- **Promos were inserted into immutable playlists during a schedule fire.** A scheduled event clears the queue and loads its items over several seconds (throttled adds + 422 retries), but the event lock that suppresses promos was only recorded *after* the entire load finished. Meanwhile the state poller (every ~3s) saw a partially-built queue with no lock and slotted a general promo between the freshly-added immutable items. `PromoDirector` now exposes a re-entrant `suppressed()` guard that `fire_schedule` (and manual playlist import) holds for the whole load — spanning through `set_active_schedule`, so for an immutable event the persistent lock is already live by the time suppression lifts (a clean handoff with no race window). When suppression releases, the next poll re-baselines now-playing instead of treating the bulk load as content advancing, so no promo fires on the wrong boundary. This also satisfies the general rule: never evaluate promos while a bulk queue insert/append is in progress, regardless of playlist type.
+
+[0.15.2]: https://github.com/grobertson/kryten-webqueue/releases/tag/v0.15.2
+
 ## [0.15.1] — 2026-06-17
 
 ### Fixed

{kryten_webqueue-0.15.1 → kryten_webqueue-0.15.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryten-webqueue
-Version: 0.15.1
+Version: 0.15.2
 Summary: Netflix/Tubi-style catalog browser and pay-to-play queue management for CyTube
 Author: grobertson
 License-Expression: MIT

{kryten_webqueue-0.15.1 → kryten_webqueue-0.15.2}/kryten_webqueue/app.py

@@ -147,6 +147,7 @@ async def lifespan(app: FastAPI):
         db=db, api_gate=api_gate, shadow=shadow, ws_manager=ws_manager,
         add_delay_sec=config.playlist_bulk_add_delay_sec,
         add_max_retries=config.playlist_bulk_add_max_retries,
+        promo_director=promo_director,
     )
     await scheduler.start()
     app.state.scheduler = scheduler

kryten_webqueue-0.15.2/kryten_webqueue/playlists/fire.py

@@ -0,0 +1,136 @@
+import asyncio
+import logging
+from contextlib import nullcontext
+from datetime import datetime, timedelta, UTC
+
+from ..queue.ordering import refund_item
+from .bulk_add import add_item_throttled
+
+logger = logging.getLogger(__name__)
+
+_queue_lock = asyncio.Lock()
+
+
+async def fire_schedule(
+    *,
+    schedule_id: int,
+    api_gate,
+    db,
+    shadow,
+    ws_manager,
+    add_delay_sec: float = 0.0,
+    add_max_retries: int = 0,
+    promo_director=None,
+):
+    """Fire a scheduled playlist: clear queue, refund displaced pay items, load playlist.
+
+    Promo insertion is suppressed for the whole load (via ``promo_director``):
+    promos must never be slotted between items while the playlist is still being
+    built. Suppression spans through ``set_active_schedule`` so that, for an
+    immutable event, the persistent event lock is already recorded by the time
+    suppression lifts — a clean handoff with no window for a stray insertion.
+    """
+    async with _queue_lock:
+        schedule = await db.get_schedule(schedule_id)
+        if not schedule:
+            logger.error(f"Schedule {schedule_id} not found")
+            return
+
+        playlist_id = schedule["playlist_id"]
+        playlist = await db.get_saved_playlist(playlist_id)
+        if not playlist:
+            logger.error(f"Playlist {playlist_id} not found for schedule {schedule_id}")
+            return
+
+        suppress_ctx = (
+            promo_director.suppressed(f"schedule fire {schedule_id}")
+            if promo_director is not None
+            else nullcontext()
+        )
+        with suppress_ctx:
+            # Refund all pay items currently in queue
+            pay_items = await db.get_pay_items()
+            for item in pay_items:
+                await refund_item(api_gate=api_gate, db=db, uid=item["uid"], reason="schedule_displaced")
+
+            # Clear the CyTube playlist
+            await api_gate.playlist_clear()
+
+            # Load scheduled playlist items
+            items = await db.get_saved_playlist_items(playlist_id)
+            total_duration = 0
+            last_item_uid = None
+            for index, item in enumerate(items):
+                # Throttle consecutive adds so CyTube can validate each item before
+                # the next arrives (avoids transient queueFail/422 under load).
+                if index and add_delay_sec:
+                    await asyncio.sleep(add_delay_sec)
+                try:
+                    add_result = await add_item_throttled(
+                        api_gate,
+                        media_type=item["media_type"],
+                        media_id=item["media_id"],
+                        position="end",
+                        max_retries=add_max_retries,
+                        retry_delay_sec=add_delay_sec or 0.5,
+                    )
+                    if isinstance(add_result, dict) and add_result.get("uid") is not None:
+                        last_item_uid = add_result["uid"]
+                    total_duration += item.get("duration_sec", 0) or 0
+                except Exception as e:
+                    logger.warning(f"Schedule fire: failed to add {item['media_id']}: {e}")
+
+            # Append the optional fallback (mutable) playlist AFTER the event items so
+            # the live queue isn't left empty once the event is exhausted. The
+            # fallback items are not part of the "scheduled event", so they do not
+            # change last_item_uid (the event lock still lifts when the last EVENT
+            # item begins) and they remain available for pay-to-play/search.
+            fallback_id = schedule.get("fallback_playlist_id")
+            if fallback_id:
+                fallback_items = await db.get_saved_playlist_items(fallback_id)
+                for index, item in enumerate(fallback_items):
+                    if index and add_delay_sec:
+                        await asyncio.sleep(add_delay_sec)
+                    try:
+                        await add_item_throttled(
+                            api_gate,
+                            media_type=item["media_type"],
+                            media_id=item["media_id"],
+                            position="end",
+                            max_retries=add_max_retries,
+                            retry_delay_sec=add_delay_sec or 0.5,
+                        )
+                    except Exception as e:
+                        logger.warning(f"Schedule fire: failed to add fallback {item['media_id']}: {e}")
+                if fallback_items:
+                    logger.info(
+                        f"Schedule {schedule_id}: appended {len(fallback_items)} fallback item(s) "
+                        f"from playlist {fallback_id}"
+                    )
+
+            # Update active schedule (recorded *inside* the suppression window so
+            # the event lock is live before promos resume).
+            now = datetime.now(UTC)
+            await db.set_active_schedule(
+                schedule_id=schedule_id,
+                playlist_id=playlist_id,
+                is_immutable=playlist.get("is_immutable", False),
+                started_at=now.isoformat(),
+                estimated_end_at=(now + timedelta(seconds=total_duration)).isoformat(),
+                last_item_uid=last_item_uid,
+            )
+
+            # Mark schedule as fired
+            await db.mark_schedule_fired(schedule_id, now.isoformat())
+
+        # Notify WS clients
+        await ws_manager.broadcast({
+            "type": "schedule_fired",
+            "data": {
+                "schedule_id": schedule_id,
+                "playlist_name": playlist["name"],
+                "is_immutable": playlist.get("is_immutable", False),
+            },
+        })
+
+        logger.info(f"Schedule {schedule_id} fired: playlist '{playlist['name']}' ({len(items)} items)")

{kryten_webqueue-0.15.1 → kryten_webqueue-0.15.2}/kryten_webqueue/playlists/importer.py

@@ -1,6 +1,7 @@
 import asyncio
 import logging
 import re
+from contextlib import nullcontext
 
 from .bulk_add import add_item_throttled
 
@@ -62,12 +63,14 @@ def _manifest_url_for_token(token: str, mediacms_url: str | None) -> str | None:
 class PlaylistImporter:
     """Imports items from a saved playlist into the live CyTube queue."""
 
-    def __init__(self, *, api_gate, db, shadow, add_delay_sec: float = 0.0, add_max_retries: int = 0):
+    def __init__(self, *, api_gate, db, shadow, add_delay_sec: float = 0.0, add_max_retries: int = 0,
+                 promo_director=None):
         self._api_gate = api_gate
         self._db = db
         self._shadow = shadow
         self._add_delay_sec = add_delay_sec
         self._add_max_retries = add_max_retries
+        self._promo_director = promo_director
 
     async def import_playlist(self, playlist_id: int) -> dict:
         """Import all items from a saved playlist into the live queue."""
@@ -75,29 +78,38 @@ class PlaylistImporter:
         if not items:
             return {"success": False, "error": "Playlist is empty"}
 
+        # Suppress promo insertion for the whole load so promos aren't slotted
+        # between items while the playlist is still being built.
+        suppress_ctx = (
+            self._promo_director.suppressed(f"playlist import {playlist_id}")
+            if self._promo_director is not None
+            else nullcontext()
+        )
+
         added = 0
         errors = 0
-        for index, item in enumerate(items):
-            # Throttle consecutive adds so CyTube can validate each item before
-            # the next arrives (avoids transient queueFail/422 under load).
-            if index and self._add_delay_sec:
-                await asyncio.sleep(self._add_delay_sec)
-            try:
-                result = await add_item_throttled(
-                    self._api_gate,
-                    media_type=item["media_type"],
-                    media_id=item["media_id"],
-                    position="end",
-                    max_retries=self._add_max_retries,
-                    retry_delay_sec=self._add_delay_sec or 0.5,
-                )
-                if result.get("success"):
-                    added += 1
-                else:
+        with suppress_ctx:
+            for index, item in enumerate(items):
+                # Throttle consecutive adds so CyTube can validate each item before
+                # the next arrives (avoids transient queueFail/422 under load).
+                if index and self._add_delay_sec:
+                    await asyncio.sleep(self._add_delay_sec)
+                try:
+                    result = await add_item_throttled(
+                        self._api_gate,
+                        media_type=item["media_type"],
+                        media_id=item["media_id"],
+                        position="end",
+                        max_retries=self._add_max_retries,
+                        retry_delay_sec=self._add_delay_sec or 0.5,
+                    )
+                    if result.get("success"):
+                        added += 1
+                    else:
+                        errors += 1
+                except Exception as e:
+                    logger.warning(f"Failed to add {item['media_id']}: {e}")
                     errors += 1
-            except Exception as e:
-                logger.warning(f"Failed to add {item['media_id']}: {e}")
-                errors += 1
 
         return {"success": True, "added": added, "errors": errors}
 

{kryten_webqueue-0.15.1 → kryten_webqueue-0.15.2}/kryten_webqueue/playlists/scheduler.py

@@ -27,13 +27,15 @@ def _next_occurrence(rrule_str: str, dtstart: datetime, after: datetime) -> date
 class PlaylistScheduler:
     """APScheduler-based scheduler for playlist fire events."""
 
-    def __init__(self, *, db, api_gate, shadow, ws_manager, add_delay_sec: float = 0.0, add_max_retries: int = 0):
+    def __init__(self, *, db, api_gate, shadow, ws_manager, add_delay_sec: float = 0.0, add_max_retries: int = 0,
+                 promo_director=None):
         self._db = db
         self._api_gate = api_gate
         self._shadow = shadow
         self._ws_manager = ws_manager
         self._add_delay_sec = add_delay_sec
         self._add_max_retries = add_max_retries
+        self._promo_director = promo_director
         self._scheduler = AsyncIOScheduler()
 
     async def start(self):
@@ -100,6 +102,7 @@ class PlaylistScheduler:
             ws_manager=self._ws_manager,
             add_delay_sec=self._add_delay_sec,
             add_max_retries=self._add_max_retries,
+            promo_director=self._promo_director,
         )
         # After an automatic timed fire, advance recurring schedules to their
         # next occurrence and re-arm. (Manual "Fire Now" does NOT advance the

{kryten_webqueue-0.15.1 → kryten_webqueue-0.15.2}/kryten_webqueue/promos/director.py

@@ -22,6 +22,7 @@ director is a no-op while an immutable scheduled event is locking the queue.
 
 import logging
 import random
+from contextlib import contextmanager
 from datetime import datetime, UTC
 
 from ..queue.ordering import _now_playing_uid
@@ -83,6 +84,17 @@ class PromoDirector:
         self._last_clip_token: dict[str, str] = {}   # promo_type -> last clip media_id
         self._seq_index: dict[str, int] = {}          # promo_type -> next sequential index
 
+        # Suppression guard. Held (re-entrantly) by bulk live-queue loaders
+        # (schedule fire, playlist import) so promos are never inserted *into* a
+        # playlist while it is still being built. Without this, the poller runs
+        # every few seconds during the multi-second load and slots promos
+        # between freshly-added items — including immutable ones, because the
+        # event lock isn't recorded until the load finishes.
+        self._suppress_depth: int = 0
+        # Set when suppression lifts so the next poll re-baselines now-playing
+        # instead of treating the post-load discontinuity as content advancing.
+        self._needs_rebaseline: bool = False
+
         # Injectable for tests
         self._rng = random.Random()
         self._now = lambda: datetime.now(UTC)
@@ -97,6 +109,36 @@ class PromoDirector:
         self._config = config
         logger.info("PromoDirector config updated (enabled=%s)", getattr(config, "enabled", None))
 
+    @property
+    def is_suppressed(self) -> bool:
+        """True while a bulk live-queue operation has paused promo insertion."""
+        return self._suppress_depth > 0
+
+    @contextmanager
+    def suppressed(self, reason: str):
+        """Pause promo insertion for the duration of a bulk queue operation.
+
+        Re-entrant: nested holders each bump a depth counter; promos resume only
+        once the outermost holder exits. Use around any operation that adds a
+        run of items to the *live* queue (schedule fire, playlist import) so the
+        director never inserts a promo into a playlist that is still loading.
+
+        On release the next poll re-baselines now-playing rather than counting
+        the load as content advancing, so a promo doesn't fire on the wrong
+        boundary immediately afterwards.
+        """
+        self._suppress_depth += 1
+        if self._suppress_depth == 1:
+            logger.info("Promo insertion suppressed: %s", reason)
+        try:
+            yield
+        finally:
+            self._suppress_depth -= 1
+            if self._suppress_depth <= 0:
+                self._suppress_depth = 0
+                self._needs_rebaseline = True
+                logger.info("Promo insertion resumed (after: %s)", reason)
+
     # --- Play-order helpers -------------------------------------------------
 
     @staticmethod
@@ -365,6 +407,13 @@ class PromoDirector:
         """
         if not self._config.enabled:
             return None
+        if self._suppress_depth > 0:
+            logger.debug(
+                "Viewer's-Choice skipped for paid uid=%s: insertion suppressed "
+                "(bulk queue operation in progress)",
+                content_uid,
+            )
+            return None
         items = self._shadow.items
         if self._has_lead_in(content_uid, items):
             logger.debug(
@@ -392,9 +441,31 @@ class PromoDirector:
         if not cfg.enabled:
             return
 
+        # Frozen while a bulk live-queue operation (schedule fire / playlist
+        # import) is loading items. Promos must never land *inside* a playlist
+        # that is still being built — this is what slips promos between immutable
+        # items before the event lock is recorded.
+        if self._suppress_depth > 0:
+            logger.debug(
+                "Promo on_poll skipped: insertion suppressed (bulk queue operation in progress)"
+            )
+            return
+
         np_uid = await _now_playing_uid(self._api_gate, self._shadow)
         np_is_promo = self._is_promo_uid(np_uid)
 
+        # After a bulk queue operation the playlist is discontinuous; re-baseline
+        # now-playing without counting it as content advancing so we don't fire a
+        # promo on the wrong boundary on the very next cycle.
+        if self._needs_rebaseline:
+            self._needs_rebaseline = False
+            self._last_np_uid = np_uid
+            self._last_np_is_promo = np_is_promo
+            logger.debug(
+                "Promo baseline reset after bulk queue operation (np_uid=%s)", np_uid
+            )
+            return
+
         # Advance detection: a finished *content* item bumps the cadence counter.
         if np_uid != self._last_np_uid:
             if self._last_np_uid is not None and not self._last_np_is_promo:

{kryten_webqueue-0.15.1 → kryten_webqueue-0.15.2}/kryten_webqueue/routes/admin_playlists.py

@@ -112,6 +112,7 @@ async def import_to_live(request: Request, playlist_id: int, user: dict = Depend
         shadow=request.app.state.shadow,
         add_delay_sec=config.playlist_bulk_add_delay_sec,
         add_max_retries=config.playlist_bulk_add_max_retries,
+        promo_director=getattr(request.app.state, "promo_director", None),
     )
     result = await importer.import_playlist(playlist_id)
     return result

{kryten_webqueue-0.15.1 → kryten_webqueue-0.15.2}/kryten_webqueue/routes/admin_schedules.py

@@ -121,6 +121,7 @@ async def fire_now(request: Request, schedule_id: int, user: dict = Depends(requ
         ws_manager=request.app.state.ws_manager,
         add_delay_sec=config.playlist_bulk_add_delay_sec,
         add_max_retries=config.playlist_bulk_add_max_retries,
+        promo_director=getattr(request.app.state, "promo_director", None),
     )
     return {"success": True}
 

{kryten_webqueue-0.15.1 → kryten_webqueue-0.15.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kryten-webqueue"
-version = "0.15.1"
+version = "0.15.2"
 description = "Netflix/Tubi-style catalog browser and pay-to-play queue management for CyTube"
 readme = "README.md"
 license = "MIT"

{kryten_webqueue-0.15.1 → kryten_webqueue-0.15.2}/tests/test_promo_director.py

@@ -323,6 +323,80 @@ async def test_noop_during_immutable_event():
     assert _promo_items(shadow) == []
 
 
+async def test_noop_while_suppressed():
+    # While a bulk queue load holds the suppression guard, on_poll must insert
+    # nothing — even though a Feature-Presentation lead-in is otherwise due.
+    shadow = _FakeShadow([_content(10), _content(20, duration=3600)], now_playing={"uid": 10})
+    api = _FakeApiGate(now_playing={"uid": 10})
+    db = _FakeDb(pools={"feature_presentation": [_clip("fp1")]})
+    d = _director(api, shadow, db)
+
+    with d.suppressed("bulk load"):
+        assert d.is_suppressed is True
+        await d.on_poll()
+        assert _promo_items(shadow) == []
+        assert api.adds == []
+
+    # Guard released; depth back to zero.
+    assert d.is_suppressed is False
+
+
+async def test_suppression_is_reentrant():
+    shadow = _FakeShadow([_content(10), _content(20, duration=3600)], now_playing={"uid": 10})
+    api = _FakeApiGate(now_playing={"uid": 10})
+    db = _FakeDb(pools={"feature_presentation": [_clip("fp1")]})
+    d = _director(api, shadow, db)
+
+    with d.suppressed("outer"):
+        with d.suppressed("inner"):
+            assert d.is_suppressed is True
+            await d.on_poll()
+            assert _promo_items(shadow) == []
+        # Inner released, outer still holds.
+        assert d.is_suppressed is True
+        await d.on_poll()
+        assert _promo_items(shadow) == []
+    assert d.is_suppressed is False
+
+
+async def test_first_poll_after_suppression_rebaselines_without_inserting():
+    # When suppression lifts, the next poll re-baselines now-playing instead of
+    # treating the bulk load as content advancing — so no promo fires on that
+    # boundary. The following poll resumes normal behaviour.
+    shadow = _FakeShadow([_content(10), _content(20, duration=3600)], now_playing={"uid": 10})
+    api = _FakeApiGate(now_playing={"uid": 10})
+    db = _FakeDb(pools={"feature_presentation": [_clip("fp1")]})
+    d = _director(api, shadow, db)
+
+    with d.suppressed("bulk load"):
+        await d.on_poll()
+    assert _promo_items(shadow) == []
+
+    # First post-suppression poll: re-baseline only, no insertion.
+    await d.on_poll()
+    assert _promo_items(shadow) == []
+
+    # Second poll: normal evaluation resumes and the FP lead-in is inserted.
+    await d.on_poll()
+    promos = _promo_items(shadow)
+    assert len(promos) == 1
+    assert promos[0]["promo_type"] == "feature_presentation"
+
+
+async def test_suppression_released_on_exception():
+    shadow = _FakeShadow([_content(10), _content(20, duration=3600)], now_playing={"uid": 10})
+    api = _FakeApiGate(now_playing={"uid": 10})
+    db = _FakeDb(pools={"feature_presentation": [_clip("fp1")]})
+    d = _director(api, shadow, db)
+
+    try:
+        with d.suppressed("bulk load"):
+            raise RuntimeError("load failed")
+    except RuntimeError:
+        pass
+    assert d.is_suppressed is False
+
+
 async def test_disabled_director_noop():
     shadow = _FakeShadow([_content(10), _content(20, duration=3600)], now_playing={"uid": 10})
     api = _FakeApiGate(now_playing={"uid": 10})

kryten_webqueue-0.15.1/kryten_webqueue/playlists/fire.py

@@ -1,120 +0,0 @@
-import asyncio
-import logging
-from datetime import datetime, timedelta, UTC
-
-from ..queue.ordering import refund_item
-from .bulk_add import add_item_throttled
-
-logger = logging.getLogger(__name__)
-
-_queue_lock = asyncio.Lock()
-
-
-async def fire_schedule(
-    *,
-    schedule_id: int,
-    api_gate,
-    db,
-    shadow,
-    ws_manager,
-    add_delay_sec: float = 0.0,
-    add_max_retries: int = 0,
-):
-    """Fire a scheduled playlist: clear queue, refund displaced pay items, load playlist."""
-    async with _queue_lock:
-        schedule = await db.get_schedule(schedule_id)
-        if not schedule:
-            logger.error(f"Schedule {schedule_id} not found")
-            return
-
-        playlist_id = schedule["playlist_id"]
-        playlist = await db.get_saved_playlist(playlist_id)
-        if not playlist:
-            logger.error(f"Playlist {playlist_id} not found for schedule {schedule_id}")
-            return
-
-        # Refund all pay items currently in queue
-        pay_items = await db.get_pay_items()
-        for item in pay_items:
-            await refund_item(api_gate=api_gate, db=db, uid=item["uid"], reason="schedule_displaced")
-
-        # Clear the CyTube playlist
-        await api_gate.playlist_clear()
-
-        # Load scheduled playlist items
-        items = await db.get_saved_playlist_items(playlist_id)
-        total_duration = 0
-        last_item_uid = None
-        for index, item in enumerate(items):
-            # Throttle consecutive adds so CyTube can validate each item before
-            # the next arrives (avoids transient queueFail/422 under load).
-            if index and add_delay_sec:
-                await asyncio.sleep(add_delay_sec)
-            try:
-                add_result = await add_item_throttled(
-                    api_gate,
-                    media_type=item["media_type"],
-                    media_id=item["media_id"],
-                    position="end",
-                    max_retries=add_max_retries,
-                    retry_delay_sec=add_delay_sec or 0.5,
-                )
-                if isinstance(add_result, dict) and add_result.get("uid") is not None:
-                    last_item_uid = add_result["uid"]
-                total_duration += item.get("duration_sec", 0) or 0
-            except Exception as e:
-                logger.warning(f"Schedule fire: failed to add {item['media_id']}: {e}")
-
-        # Append the optional fallback (mutable) playlist AFTER the event items so
-        # the live queue isn't left empty once the event is exhausted. The
-        # fallback items are not part of the "scheduled event", so they do not
-        # change last_item_uid (the event lock still lifts when the last EVENT
-        # item begins) and they remain available for pay-to-play/search.
-        fallback_id = schedule.get("fallback_playlist_id")
-        if fallback_id:
-            fallback_items = await db.get_saved_playlist_items(fallback_id)
-            for index, item in enumerate(fallback_items):
-                if index and add_delay_sec:
-                    await asyncio.sleep(add_delay_sec)
-                try:
-                    await add_item_throttled(
-                        api_gate,
-                        media_type=item["media_type"],
-                        media_id=item["media_id"],
-                        position="end",
-                        max_retries=add_max_retries,
-                        retry_delay_sec=add_delay_sec or 0.5,
-                    )
-                except Exception as e:
-                    logger.warning(f"Schedule fire: failed to add fallback {item['media_id']}: {e}")
-            if fallback_items:
-                logger.info(
-                    f"Schedule {schedule_id}: appended {len(fallback_items)} fallback item(s) "
-                    f"from playlist {fallback_id}"
-                )
-
-        # Update active schedule
-        now = datetime.now(UTC)
-        await db.set_active_schedule(
-            schedule_id=schedule_id,
-            playlist_id=playlist_id,
-            is_immutable=playlist.get("is_immutable", False),
-            started_at=now.isoformat(),
-            estimated_end_at=(now + timedelta(seconds=total_duration)).isoformat(),
-            last_item_uid=last_item_uid,
-        )
-
-        # Mark schedule as fired
-        await db.mark_schedule_fired(schedule_id, now.isoformat())
-
-        # Notify WS clients
-        await ws_manager.broadcast({
-            "type": "schedule_fired",
-            "data": {
-                "schedule_id": schedule_id,
-                "playlist_name": playlist["name"],
-                "is_immutable": playlist.get("is_immutable", False),
-            },
-        })
-
-        logger.info(f"Schedule {schedule_id} fired: playlist '{playlist['name']}' ({len(items)} items)")