.forgejo/workflows/publish-docker.yml

@@ -55,16 +55,13 @@ jobs:
       # node:20-alpine n'a pas git préinstallé - même approche de clone
       # manuel que le job publish (pas d'actions/checkout, action JS qui a
       # ses propres soucis dans les conteneurs Alpine minimalistes ici).
-      # Sur une PR, `ref_name` vaut le numéro de la PR (ex. `29`), qui n'est
-      # pas une ref récupérable ("couldn't find remote ref 29") : on récupère
-      # alors la branche source de la PR (`head_ref`, vide hors PR).
       - name: Récupérer les sources
         run: |
           set -eu
           apk add --no-cache git
           git init -q
           git remote add origin "${{ github.server_url }}/${{ github.repository }}.git"
-          git fetch -q --depth 1 origin "${{ github.head_ref || github.ref_name }}"
+          git fetch -q --depth 1 origin "${{ github.ref_name }}"
           git checkout -q FETCH_HEAD
 
       - name: Serveur - installer les dépendances

.gitignore

@@ -21,9 +21,6 @@ server/dist/
 client/dist/
 *.tsbuildinfo
 
-## Runtime data (static watch parties - see server/src/services/StaticPartyStore.ts)
-data/
-
 ## OS cruft
 .DS_Store
 Thumbs.db

README.md

@@ -159,7 +159,7 @@ server/           Node.js + Express + Socket.IO backend: proxies ALL Emby
                   tsc to server/dist.
   src/index.ts                    Express app + route wiring only - thin,
                                    delegates to the services below
-  src/config.ts                   env-derived config (EMBY_SERVER_URL, PORT, DATA_DIR)
+  src/config.ts                   env-derived config (EMBY_SERVER_URL, PORT)
   src/types.ts                    shared interfaces (Party, ItemDto, the
                                    Socket.IO event maps, ...)
   src/Logger.ts                   party/stream lifecycle logging
@@ -245,14 +245,9 @@ build stage, so nothing needs building beforehand:
 
 ```bash
 docker build -f server/Dockerfile -t watchparty .
-docker run -d --name watchparty -p 3000:3000 -v "$(pwd)/data:/data" -e EMBY_SERVER_URL=https://theater.media.kyuno.fr watchparty
+docker run -d --name watchparty -p 3000:3000 -e EMBY_SERVER_URL=https://theater.media.kyuno.fr watchparty
 ```
 
-The `/data` volume holds the static (persistent) watch parties
-(`DATA_DIR`, see [`spec/static-watch-party.md`](spec/static-watch-party.md)).
-Without it they're lost whenever the container is recreated.
-`docker-compose.yml` already mounts it.
-
 Then put it behind your existing reverse proxy like everything else
 (`theater.media.kyuno.fr`, `git.dev.kyuno.fr`, ...), e.g.
 `watchparty.kyuno.fr` → `http://<container>:3000`.

client/src/api/party.ts

@@ -150,9 +150,6 @@ export interface PartyConnection {
   sendPlaystate(isPaused: boolean, positionTicks: number): void;
   /** Host-only: advance the party's queue (e.g. to the next episode). */
   next(): void;
-  /** Host-only: the last queued item played to its end - lets the server
-   *  count it as watched (there's no "next" to send for it). */
-  itemEnded(): void;
   /** Asks the host (and tells everyone else) "please pause". Video only -
    *  a music party has no host to ask, see voteSkip/setMusicPaused. */
   requestPause(): void;
@@ -233,9 +230,6 @@ export function connectParty(partyId: string, callbacks: PartyConnectionCallback
     next() {
       socket.emit('next');
     },
-    itemEnded() {
-      socket.emit('itemEnded');
-    },
     requestPause() {
       socket.emit('requestPause');
     },

client/src/api/staticParty.ts

@@ -1,74 +0,0 @@
-// Static (persistent) watch parties - REST only, same origin, session
-// cookie auth (see embyApi.ts). A static party's live sessions are
-// ordinary parties: once one of these calls returns a partyId, everything
-// else goes through api/party.ts and the normal player, unchanged. See
-// server/src/services/StaticPartyService.ts and spec/static-watch-party.md.
-import type { StaticPartyDetailDto, StaticPartySummaryDto } from '../types';
-
-/** Same contract as api/party.ts's own helper: JSON in/out, the server's
- *  `error` message thrown as-is (they're written to be shown to users). */
-async function apiFetch<T>(path: string, options: RequestInit = {}): Promise<T> {
-  let res: Response;
-  try {
-    res = await fetch(path, {
-      credentials: 'same-origin',
-      ...options,
-      headers: { 'Content-Type': 'application/json', ...(options.headers || {}) }
-    });
-  } catch (err) {
-    console.error('[staticParty] network error', path, err);
-    throw new Error('Serveur injoignable.');
-  }
-  if (!res.ok) {
-    const body = await res.json().catch(() => ({}));
-    console.warn('[staticParty] request failed', path, res.status, body.error);
-    throw new Error(body.error || `Request failed: ${res.status}`);
-  }
-  return res.json() as Promise<T>;
-}
-
-/** Every static watch party, with the viewer's own missed count. */
-export async function listStaticParties(): Promise<StaticPartySummaryDto[]> {
-  const data = await apiFetch<{ staticParties: StaticPartySummaryDto[] }>('/api/static-parties');
-  return data.staticParties;
-}
-
-/** Creates one from a series or a video playlist (`sourceId`). */
-export function createStaticParty(sourceId: string, name?: string): Promise<StaticPartyDetailDto> {
-  return apiFetch('/api/static-parties', { method: 'POST', body: JSON.stringify({ sourceId, name }) });
-}
-
-/** Everything about one static watch party, from the viewer's side. */
-export function getStaticParty(id: string): Promise<StaticPartyDetailDto> {
-  return apiFetch(`/api/static-parties/${encodeURIComponent(id)}`);
-}
-
-/** Become a member. */
-export function joinStaticParty(id: string): Promise<{ ok: true }> {
-  return apiFetch(`/api/static-parties/${encodeURIComponent(id)}/join`, { method: 'POST' });
-}
-
-/** Stop being a member (drops the viewer's own progress). */
-export function leaveStaticParty(id: string): Promise<{ ok: true }> {
-  return apiFetch(`/api/static-parties/${encodeURIComponent(id)}/leave`, { method: 'POST' });
-}
-
-/** Delete it for everyone - creator only. */
-export function deleteStaticParty(id: string): Promise<{ ok: true }> {
-  return apiFetch(`/api/static-parties/${encodeURIComponent(id)}`, { method: 'DELETE' });
-}
-
-/** "Marquer comme vu". */
-export function markStaticItemWatched(id: string, itemId: string): Promise<{ ok: true }> {
-  return apiFetch(`/api/static-parties/${encodeURIComponent(id)}/items/${encodeURIComponent(itemId)}/watched`, { method: 'POST' });
-}
-
-/** Launches the group's next session, or joins the one running. */
-export function startStaticSession(id: string): Promise<{ partyId: string }> {
-  return apiFetch(`/api/static-parties/${encodeURIComponent(id)}/session`, { method: 'POST' });
-}
-
-/** Catches up on `itemIds` - alone, or as a watch party others can join. */
-export function startCatchUp(id: string, itemIds: string[], mode: 'solo' | 'party'): Promise<{ partyId: string }> {
-  return apiFetch(`/api/static-parties/${encodeURIComponent(id)}/catch-up`, { method: 'POST', body: JSON.stringify({ itemIds, mode }) });
-}

client/src/app.ts

@@ -10,8 +10,6 @@ import { renderArtist } from './views/artist/Artist';
 import { renderAlbum } from './views/album/Album';
 import { renderPlaylist } from './views/playlist/Playlist';
 import { renderPartyPlayer } from './views/player/Player';
-import { renderStaticParty } from './views/staticParty/StaticParty';
-import { renderStaticParties } from './views/staticParties/StaticParties';
 
 route('/', () => navigate('/home'));
 route('/login', renderLogin);
@@ -22,8 +20,6 @@ route('/artist/:id', renderArtist);
 route('/album/:id', renderAlbum);
 route('/playlist/:id', renderPlaylist);
 route('/party/:id', renderPartyPlayer);
-route('/static', renderStaticParties);
-route('/static/:id', renderStaticParty);
 
 /**
  * Renders either the bare login screen or the full shell (sidebar +

client/src/shell/Shell.html

@@ -3,7 +3,6 @@
     <div class="sidebarBrand">Watch Party</div>
     <nav class="sidebarNav" id="sidebarNav">
       <a href="#/home" class="navItem">Accueil</a>
-      <a href="#/static" class="navItem">Lounge parties</a>
       <div class="navSectionLabel">Bibliothèques</div>
       <p class="hint" id="libStatus"><span class="spinner"></span>Chargement...</p>
     </nav>
@@ -42,7 +41,6 @@
          plain scrim tap-only close used to leave unsolved). -->
     <div class="sheetGrabberHandle" id="sheetGrabberHandle"><div class="sheetGrabber"></div></div>
     <a href="#/home" class="navItem sheetPrimary"><span class="navIcon" data-icon="home"></span>Accueil</a>
-    <a href="#/static" class="navItem sheetPrimary"><span class="navIcon" data-icon="static"></span>Lounge parties</a>
     <div class="navSectionLabel">Bibliothèques</div>
     <div class="sheetGrid" id="mobileLibGrid"></div>
     <div id="mobilePlaylistsSlot"></div>

client/src/shell/Shell.ts

@@ -18,8 +18,6 @@ const SHOWS_ICON_SVG = '<svg viewBox="0 0 24 24"><rect x="3" y="5.5" width="18"
 const MUSIC_ICON_SVG = '<svg viewBox="0 0 24 24"><circle cx="8" cy="17" r="2.6" fill="none" stroke="currentColor" stroke-width="1.8"/><path d="M10.5 17V5.5l7-1.5v10" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/><circle cx="17.5" cy="14" r="2.6" fill="none" stroke="currentColor" stroke-width="1.8"/></svg>';
 const MUSICVIDEOS_ICON_SVG = '<svg viewBox="0 0 24 24"><rect x="3" y="5.5" width="18" height="13" rx="1.5" fill="none" stroke="currentColor" stroke-width="1.8"/><path d="M10 9.5 15.5 12 10 14.5Z" fill="currentColor"/></svg>';
 const PLAYLISTS_ICON_SVG = '<svg viewBox="0 0 24 24"><circle cx="4.5" cy="7" r="1.3" fill="currentColor"/><circle cx="4.5" cy="12" r="1.3" fill="currentColor"/><circle cx="4.5" cy="17" r="1.3" fill="currentColor"/><line x1="9" y1="7" x2="20" y2="7" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"/><line x1="9" y1="12" x2="20" y2="12" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"/><line x1="9" y1="17" x2="20" y2="17" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"/></svg>';
-// The "Lounge parties" tab (static watch parties) - a circular "resume" arrow.
-const STATIC_PARTIES_ICON_SVG = '<svg viewBox="0 0 24 24"><path d="M19.5 12a7.5 7.5 0 1 1-2.2-5.3" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"/><path d="M19.5 4v4h-4" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/><path d="M10 9l5 3-5 3Z" fill="currentColor"/></svg>';
 // Emby could in principle add a CollectionType this app doesn't map yet
 // (server/src/services/CatalogService.ts's VISIBLE_COLLECTION_TYPES
 // would need updating first either way) - falls back to a plain folder
@@ -55,7 +53,6 @@ export async function renderShell(appEl: HTMLElement): Promise<HTMLElement> {
   appEl.innerHTML = html;
 
   appEl.querySelector('[data-icon="home"]')!.innerHTML = HOME_ICON_SVG;
-  appEl.querySelector('[data-icon="static"]')!.innerHTML = STATIC_PARTIES_ICON_SVG;
 
   // Mounted once, outside #mainContent, so a listen party survives
   // navigating the router - see musicBar/MusicBar.ts's header comment.
@@ -101,11 +98,8 @@ export async function renderShell(appEl: HTMLElement): Promise<HTMLElement> {
 
   const highlight = () => {
     appEl.querySelectorAll('.navItem').forEach((a) => {
-      const href = a.getAttribute('href');
+      const isHome = a.getAttribute('href') === '#/home';
-      const isHome = href === '#/home';
+      a.classList.toggle('active', a.getAttribute('href') === location.hash || (isHome && !location.hash));
-      // The static-parties tab stays highlighted on one party's own page too.
-      const isStaticSection = href === '#/static' && location.hash.startsWith('#/static/');
-      a.classList.toggle('active', href === location.hash || (isHome && !location.hash) || isStaticSection);
     });
   };
   highlight();

client/src/tiles.ts

@@ -61,9 +61,7 @@ const DRILL_DOWN: Record<string, { route: string; label: string }> = {
 function posterTileHtml(item: ItemDto): string {
   const drill = item.type ? DRILL_DOWN[item.type] : undefined;
   const drillHref = drill ? `#/${drill.route}/${item.id}` : null;
-  // Video -> "watch party", audio -> "listen party" - see the party kinds
+  const partyLabel = item.type === 'Audio' ? 'Écouter ensemble' : 'Lancer une watch party';
-  // in docs/architecture.md (the third, "lounge party", is the static one).
-  const partyLabel = item.type === 'Audio' ? 'Lancer une listen party' : 'Lancer une watch party';
   return `
     <div class="tile">
       ${drillHref ? `<a href="${drillHref}" class="tileLink" aria-label="${escapeHtml(item.name)}"></a>` : ''}
@@ -118,7 +116,7 @@ export function tileHtml(item: ItemDto): string {
 }
 
 /**
- * Wires up every "Lancer une watch/listen party" button inside `container`, now
+ * Wires up every "Lancer une watch party" button inside `container`, now
  * and for any tile added to it later. `onStart(itemId)` does the actual
  * work (create the party + navigate) - kept as a caller-supplied callback
  * so this module doesn't need to depend on api/party.ts/router.ts itself.
@@ -134,7 +132,6 @@ export function wireTileButtons(container: ParentNode, onStart: (itemId: string)
     const btn = (e.target as HTMLElement).closest<HTMLButtonElement>('.startPartyBtn');
     if (!btn || btn.disabled) return;
     e.preventDefault();
-    const idleLabel = btn.textContent; // "watch party" or "listen party" - put back as-is on failure
     btn.disabled = true;
     btn.textContent = 'Démarrage...';
     try {
@@ -142,7 +139,7 @@ export function wireTileButtons(container: ParentNode, onStart: (itemId: string)
     } catch (err) {
       showToast((err as Error).message, { variant: 'error' });
       btn.disabled = false;
-      btn.textContent = idleLabel;
+      btn.textContent = 'Lancer une watch party';
     }
   });
 }

client/src/types.ts

@@ -171,42 +171,6 @@ export interface LobbyPartyDto {
   positionTicks: number | null;
   isPaused: boolean | null;
   positionUpdatedUtc: number | null;
-  /** The static watch party this live session belongs to, if any. */
-  staticPartyId: string | null;
-  staticPartyName: string | null;
-}
-
-/** Mirrors server/src/types.ts's StaticPartySummaryDto - one static
- *  (persistent) watch party, as the home page lists it. */
-export interface StaticPartySummaryDto {
-  id: string;
-  name: string;
-  sourceType: 'series' | 'season' | 'playlist';
-  imageUrl: string;
-  itemCount: number;
-  groupWatchedCount: number;
-  nextItemName: string | null;
-  memberCount: number;
-  youAreMember: boolean;
-  youAreCreator: boolean;
-  missedCount: number;
-  livePartyId: string | null;
-}
-
-/** One item of a static watch party - mirrors StaticPartyItemDto. */
-export interface StaticPartyItemDto {
-  itemId: string;
-  itemName: string;
-  itemImageUrl: string;
-  groupState: 'watched' | 'next' | 'upcoming';
-  viewerWatched: boolean;
-}
-
-/** Mirrors server/src/types.ts's StaticPartyDetailDto. */
-export interface StaticPartyDetailDto extends StaticPartySummaryDto {
-  items: StaticPartyItemDto[];
-  missedItemIds: string[];
-  members: Array<{ userId: string; userName: string; watchedCount: number; isCreator: boolean }>;
 }
 
 export interface ItemChangedMsg {

client/src/views/album/Album.ts

@@ -69,7 +69,7 @@ export async function renderAlbum(root: HTMLElement, params: RouteParams): Promi
   // states) - the label lives in aria-label/title for accessibility
   // rather than as visible text, now that there's one per track instead
   // of one per page (see docs/architecture.md's "Music UI rework").
-  const startLabel = 'Lancer une listen party';
+  const startLabel = 'Écouter ensemble';
   const addLabel = 'Ajouter à la file';
   const startAlbumLabel = 'Écouter cet album';
   const addAlbumLabel = "Ajouter l'album à la file";

client/src/views/home/Home.css

@@ -60,18 +60,3 @@
   color: var(--accent-bright);
   font-weight: 600;
 }
-
-/* Which kind of party a card is - "Watch party" (video) or "Listen party"
-   (audio). Lounge parties (static) have their own tab, never this list. */
-.partyKind {
-  align-self: flex-start;
-  font-size: 10px;
-  font-weight: 700;
-  letter-spacing: .06em;
-  text-transform: uppercase;
-  padding: 1px 6px;
-  border-radius: 4px;
-}
-
-.partyKind--video { color: var(--accent-bright); background: rgba(82, 181, 75, .15); }
-.partyKind--music { color: #7fb4ff; background: rgba(127, 180, 255, .15); }

client/src/views/home/Home.html

@@ -3,7 +3,7 @@
 </div>
 
 <section class="section" id="partiesSection" hidden>
-  <h2>Parties en cours</h2>
+  <h2>Watch parties en cours</h2>
   <div id="partiesCarousel" class="carousel"></div>
 </section>
 

client/src/views/home/Home.ts

@@ -18,9 +18,7 @@ export function renderHome(root: HTMLElement): () => void {
   // label is the one piece that ticks purely client-side (from
   // createdUtc) - no point re-pushing from the server once a second just
   // for a clock.
-  // A static watch party's sessions live in their own tab
+  const lobby = connectLobby((parties) => renderParties(root, parties));
-  // (views/staticParties), not here - this list is classic parties only.
-  const lobby = connectLobby((parties) => renderParties(root, parties.filter((p) => !p.staticPartyId)));
   const elapsedTimer = window.setInterval(() => updateElapsedLabels(root), 1000);
 
   loadRecentSections(root);
@@ -59,7 +57,6 @@ function renderParties(root: HTMLElement, parties: LobbyPartyDto[]): void {
     <div class="partyCard">
       <img class="${p.mediaType === 'music' ? 'partyCardArt--square' : ''}" src="${p.itemImageUrl || ''}" alt="" onerror="this.classList.add('noImage')" />
       <div class="partyCardInfo">
-        <span class="partyKind partyKind--${p.mediaType}">${p.mediaType === 'music' ? 'Listen party' : 'Watch party'}</span>
         <strong>${escapeHtml(p.itemName || '')}</strong>
         <span class="hint">
           ${escapeHtml(p.hostUserName || '')} · ${p.memberCount} participant${p.memberCount > 1 ? 's' : ''}

client/src/views/player/Player.ts

@@ -691,10 +691,7 @@ function renderVideoPlayer(root: HTMLElement, partyId: string, party: PartyPubli
     video.addEventListener('play', onDriverStateChanged);
     video.addEventListener('pause', onDriverStateChanged);
     video.addEventListener('seeked', onDriverStateChanged);
-    // The last item ending still counts as watched (Emby Played, a static
+    video.addEventListener('ended', () => { if (hasNextQueued) conn?.next(); });
-    // watch party's progress) - "itemEnded" tells the server so, since
-    // there's no "next" to send for it.
-    video.addEventListener('ended', () => { if (hasNextQueued) conn?.next(); else conn?.itemEnded(); });
     if (!heartbeat) heartbeat = window.setInterval(reportHeartbeat, 3000);
 
     // Burn-in (image) subtitle options are host-only (see

client/src/views/playlist/Playlist.css

@@ -25,9 +25,8 @@
 
 .playlistActions {
   display: flex;
-  flex-wrap: wrap;
   align-items: center;
-  gap: 12px 16px;
+  gap: 16px;
   margin-top: 4px;
 }
 

client/src/views/playlist/Playlist.html

@@ -6,7 +6,6 @@
     <p class="hint" id="playlistMeta"></p>
     <div class="playlistActions">
       <button id="launchBtn">Lancer cette playlist</button>
-      <button class="hide" id="createStaticBtn">Créer une lounge party</button>
       <a class="linklike" id="embyLink" target="_blank" rel="noopener">Voir sur Emby</a>
     </div>
   </div>

client/src/views/playlist/Playlist.ts

@@ -2,7 +2,6 @@ import './Playlist.css';
 import html from './Playlist.html';
 import { getItem, getPlaylistItems } from '../../api/embyApi';
 import { createParty } from '../../api/party';
-import { wireCreateStaticButton } from '../staticParty/createStaticButton';
 import { joinMusicParty } from '../../musicBar/MusicBar';
 import { navigate } from '../../router';
 import type { RouteParams } from '../../router';
@@ -57,15 +56,6 @@ export async function renderPlaylist(root: HTMLElement, params: RouteParams): Pr
     return;
   }
 
-  // Video playlists only - a static watch party has no music equivalent
-  // (the server refuses one too). Same "first item decides" rule as
-  // CatalogService.splitPlaylistByMediaType.
-  if (items[0]!.type !== 'Audio') {
-    const createStaticBtn = root.querySelector('#createStaticBtn') as HTMLButtonElement;
-    createStaticBtn.classList.remove('hide');
-    wireCreateStaticButton(createStaticBtn, () => playlistId);
-  }
-
   listEl.innerHTML = items.map((item, i) => {
     const meta = item.overview || [item.artistName, item.albumName].filter(Boolean).join(' · ');
     const duration = item.durationTicks ? formatDuration(item.durationTicks / TICKS_PER_SECOND) : '';

client/src/views/series/Series.css

@@ -17,20 +17,6 @@
 
 .seriesPoster.noImage { visibility: hidden; }
 
-.seriesActions,
-.seasonActions {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 12px 16px;
-  margin-top: 8px;
-}
-
-/* The selected season's own launch buttons, between the tabs and its
-   episodes. */
-.seasonActions { margin: 0 0 16px; }
-.seasonActions button { padding: 8px 14px; font-size: 13px; }
-
 @media (max-width: 600px) {
   .seriesHeader { flex-direction: column; }
   .seriesPoster { width: 120px; }

client/src/views/series/Series.html

@@ -4,16 +4,8 @@
   <div class="seriesInfo">
     <h1 id="seriesTitle"></h1>
     <p class="seriesOverview hide" id="seriesOverview"></p>
-    <div class="seriesActions">
-      <button id="launchSeriesBtn">Lancer toute la série</button>
-      <button class="secondaryBtn" id="createStaticBtn">Créer une lounge party</button>
     <a class="linklike" id="embyLink" target="_blank" rel="noopener">Voir sur Emby</a>
   </div>
 </div>
-</div>
 <nav id="seasonTabs" class="tabs"></nav>
-<div class="seasonActions hide" id="seasonActions">
-  <button id="launchSeasonBtn">Lancer cette saison</button>
-  <button class="secondaryBtn" id="createSeasonStaticBtn">Lounge party de cette saison</button>
-</div>
 <div id="episodeList" class="episodeList"><p class="hint">Chargement...</p></div>

client/src/views/series/Series.ts

@@ -2,7 +2,6 @@ import './Series.css';
 import html from './Series.html';
 import { getItem, getSeriesEpisodes, getSeriesSeasons } from '../../api/embyApi';
 import { createParty } from '../../api/party';
-import { wireCreateStaticButton } from '../staticParty/createStaticButton';
 import { navigate } from '../../router';
 import type { RouteParams } from '../../router';
 import { escapeHtml } from '../../tiles';
@@ -36,25 +35,11 @@ export async function renderSeries(root: HTMLElement, params: RouteParams): Prom
   }
   (root.querySelector('#embyLink') as HTMLAnchorElement).href = series.embyUrl;
 
-  // Whole series: a watch party over every season from S1E1, or a lounge
-  // party over the same (see the server's seriesQueueFrom).
-  wireLaunchButton(root.querySelector('#launchSeriesBtn') as HTMLButtonElement, () => seriesId);
-  wireCreateStaticButton(root.querySelector('#createStaticBtn') as HTMLButtonElement, () => seriesId);
-
   if (!seasons.length) {
-    (root.querySelector('#launchSeriesBtn') as HTMLButtonElement).disabled = true;
-    (root.querySelector('#createStaticBtn') as HTMLButtonElement).disabled = true;
     root.querySelector('#episodeList')!.innerHTML = '<p class="hint">Aucune saison trouvée.</p>';
     return;
   }
 
-  // Just the selected season - both buttons read whichever tab is active
-  // at click time, so they're wired once rather than per tab switch.
-  let selectedSeasonId = seasons[0]!.id;
-  root.querySelector('#seasonActions')!.classList.remove('hide');
-  wireLaunchButton(root.querySelector('#launchSeasonBtn') as HTMLButtonElement, () => selectedSeasonId);
-  wireCreateStaticButton(root.querySelector('#createSeasonStaticBtn') as HTMLButtonElement, () => selectedSeasonId);
-
   const tabsEl = root.querySelector('#seasonTabs')!;
   tabsEl.innerHTML = seasons
     .map((s, i) => `<button class="tab${i === 0 ? ' active' : ''}" data-season-id="${s.id}">${escapeHtml(s.name)}</button>`)
@@ -65,35 +50,13 @@ export async function renderSeries(root: HTMLElement, params: RouteParams): Prom
       if (tab.classList.contains('active')) return;
       tabsEl.querySelectorAll('.tab').forEach((t) => t.classList.remove('active'));
       tab.classList.add('active');
-      selectedSeasonId = tab.dataset.seasonId as string;
+      loadEpisodes(root, seriesId, tab.dataset.seasonId as string);
-      loadEpisodes(root, seriesId, selectedSeasonId);
     });
   });
 
   loadEpisodes(root, seriesId, seasons[0]!.id);
 }
 
-/**
- * A button that launches a watch party over whatever `itemId()` returns
- * at click time - the series (every season) or the selected season (see
- * the server's POST /api/parties Series/Season branches) - then opens it.
- */
-function wireLaunchButton(btn: HTMLButtonElement, itemId: () => string): void {
-  const idleLabel = btn.textContent || '';
-  btn.addEventListener('click', () => {
-    btn.disabled = true;
-    btn.textContent = 'Démarrage...';
-    createParty(itemId())
-      .then((party) => navigate(`/party/${party.partyId}`))
-      .catch((err: unknown) => {
-        console.error('[series] launch failed', err);
-        showToast((err as Error).message, { variant: 'error' });
-        btn.disabled = false;
-        btn.textContent = idleLabel;
-      });
-  });
-}
-
 async function loadEpisodes(root: HTMLElement, seriesId: string, seasonId: string): Promise<void> {
   const listEl = root.querySelector('#episodeList')!;
   listEl.innerHTML = LOADING_HINT;

client/src/views/staticParties/StaticParties.css

@@ -1,81 +0,0 @@
-/* ---- "Lounge parties" tab: one card per static party ---- */
-
-.staticGrid {
-  display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
-  gap: 14px;
-}
-
-/* The whole card is the link to /static/:id. */
-.staticCard {
-  display: flex;
-  align-items: center;
-  gap: 14px;
-  background: var(--bg-header);
-  border-radius: 10px;
-  padding: 12px;
-  color: inherit;
-  text-decoration: none;
-}
-
-.staticCard:hover { background: #2b252e; }
-
-.staticCard img {
-  width: 60px;
-  height: 90px;
-  object-fit: cover;
-  border-radius: 6px;
-  background: var(--panel);
-  flex-shrink: 0;
-}
-
-.staticCard img.noImage { visibility: hidden; }
-
-.staticCardInfo {
-  flex: 1;
-  min-width: 0;
-  display: flex;
-  flex-direction: column;
-  gap: 4px;
-}
-
-.staticCardInfo strong { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
-.staticCardInfo .hint { margin: 0; }
-
-.staticCardNext {
-  font-size: 12px;
-  color: var(--muted);
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-}
-
-.staticCardBar {
-  height: 4px;
-  border-radius: 2px;
-  background: var(--panel);
-  overflow: hidden;
-}
-
-.staticCardBar > div { height: 100%; background: var(--accent); }
-
-.staticCardLive {
-  color: var(--accent-bright);
-  font-size: 12px;
-  font-weight: 600;
-}
-
-.staticCardMissed {
-  flex-shrink: 0;
-  align-self: flex-start;
-  padding: 4px 10px;
-  border-radius: 12px;
-  background: var(--danger);
-  color: #fff;
-  font-size: 12px;
-  font-weight: 600;
-}
-
-@media (max-width: 400px) {
-  .staticGrid { grid-template-columns: 1fr; }
-}

client/src/views/staticParties/StaticParties.html

@@ -1,9 +0,0 @@
-<div class="pageHeader">
-  <h1>Lounge parties</h1>
-</div>
-<p class="hint">
-  Une série ou une playlist regardée en groupe sur plusieurs séances : la progression du groupe
-  et celle de chacun sont gardées en mémoire. Pour en créer une, ouvre une série ou une playlist
-  vidéo et choisis « Créer une lounge party ».
-</p>
-<div class="staticGrid" id="staticGrid"></div>

client/src/views/staticParties/StaticParties.ts

@@ -1,77 +0,0 @@
-import './StaticParties.css';
-import html from './StaticParties.html';
-import { connectLobby } from '../../api/party';
-import { listStaticParties } from '../../api/staticParty';
-import { escapeHtml } from '../../tiles';
-import { SOURCE_LABELS } from '../staticParty/StaticParty';
-import { LOADING_HINT } from '../../loading';
-import type { StaticPartySummaryDto } from '../../types';
-
-/**
- * Route `/static` - the "Lounge parties" tab: every static
- * watch party, kept apart from the home page's classic live parties
- * (whose lobby list leaves static sessions out - see Home.ts).
- *
- * A REST list, re-fetched whenever the set of live static-party sessions
- * in the lobby changes (a session starting or ending is what moves a
- * card's "séance en cours"/progress state). Not on every lobby snapshot:
- * those also fire on every pause/join, and each list fetch reads Emby
- * once per static party (see server/src/index.ts's syncStaticSource).
- */
-export function renderStaticParties(root: HTMLElement): () => void {
-  root.innerHTML = html;
-  const grid = root.querySelector('#staticGrid') as HTMLElement;
-  grid.innerHTML = LOADING_HINT;
-
-  let sessionsKey: string | null = null;
-  const lobby = connectLobby((parties) => {
-    const key = parties.map((p) => p.staticPartyId).filter(Boolean).sort().join(',');
-    if (key === sessionsKey) return;
-    sessionsKey = key;
-    load(grid);
-  });
-
-  // Same leak-prevention contract as Home.ts: the router calls this before
-  // rendering the next view.
-  return function cleanup() {
-    lobby.disconnect();
-  };
-}
-
-/** Fetches and renders every static party into `grid`. */
-function load(grid: HTMLElement): void {
-  listStaticParties()
-    .then((parties) => {
-      if (!grid.isConnected) return; // navigated away mid-flight
-      render(grid, parties);
-    })
-    .catch((err: unknown) => {
-      console.error('[staticParties] list failed to load', err);
-      if (grid.isConnected) grid.innerHTML = `<p class="error">${escapeHtml((err as Error).message)}</p>`;
-    });
-}
-
-/** One card per static party: progress, next item, the viewer's missed
- *  count, and whether a session is running right now. */
-function render(grid: HTMLElement, parties: StaticPartySummaryDto[]): void {
-  if (!parties.length) {
-    grid.innerHTML = '<p class="hint">Aucune lounge party pour le moment.</p>';
-    return;
-  }
-  grid.innerHTML = parties.map((p) => {
-    const percent = p.itemCount ? Math.round((p.groupWatchedCount / p.itemCount) * 100) : 0;
-    return `
-      <a class="staticCard" href="#/static/${escapeHtml(p.id)}">
-        <img src="${escapeHtml(p.imageUrl)}" alt="" loading="lazy" onerror="this.classList.add('noImage')" />
-        <div class="staticCardInfo">
-          <strong>${escapeHtml(p.name)}</strong>
-          <span class="hint">${SOURCE_LABELS[p.sourceType]} · ${p.groupWatchedCount}/${p.itemCount} vus · ${p.memberCount} membre${p.memberCount > 1 ? 's' : ''}</span>
-          <div class="staticCardBar"><div style="width:${percent}%"></div></div>
-          ${p.livePartyId
-            ? '<span class="staticCardLive">● Séance en cours</span>'
-            : `<span class="staticCardNext">${p.nextItemName ? `Prochain : ${escapeHtml(p.nextItemName)}` : 'Le groupe a tout vu.'}</span>`}
-        </div>
-        ${p.missedCount ? `<span class="staticCardMissed" title="Éléments manqués">${p.missedCount} manqué${p.missedCount > 1 ? 's' : ''}</span>` : ''}
-      </a>`;
-  }).join('');
-}

client/src/views/staticParty/StaticParty.css

@@ -1,138 +0,0 @@
-/* ---- Static (persistent) watch party page ----
-   .seriesInfo/.episodeList/.episodeRow/.episodeInfo are reused as-is from
-   views/series/Series.css (always in the bundle - same precedent as
-   Playlist.css/Album.css). Only what's specific to this page lives here. */
-
-.staticHeader {
-  display: flex;
-  gap: 20px;
-  margin-bottom: 28px;
-}
-
-.staticCover {
-  width: 160px;
-  aspect-ratio: 2 / 3;
-  object-fit: cover;
-  border-radius: 8px;
-  background: var(--panel);
-  flex-shrink: 0;
-}
-
-.staticCover.noImage { visibility: hidden; }
-
-.staticBadge {
-  display: inline-block;
-  font-size: 11px;
-  font-weight: 700;
-  letter-spacing: .06em;
-  text-transform: uppercase;
-  color: var(--accent-bright);
-  margin-bottom: 6px;
-}
-
-.staticMeta { margin: 6px 0 10px; }
-
-.staticProgress {
-  height: 6px;
-  max-width: 360px;
-  border-radius: 3px;
-  background: var(--panel);
-  overflow: hidden;
-}
-
-.staticProgressFill {
-  height: 100%;
-  width: 0;
-  background: var(--accent);
-  transition: width .3s;
-}
-
-.staticNext { margin: 10px 0 14px; font-size: 14px; }
-
-.staticActions {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 12px 16px;
-}
-
-/* A quieter variant of the global green button - for actions next to a
-   primary one (joining, catching up) that shouldn't compete with it. */
-.secondaryBtn {
-  background: var(--panel);
-  color: var(--text);
-}
-
-.secondaryBtn:hover { background: #333; }
-
-.staticSectionHead {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  flex-wrap: wrap;
-  gap: 12px;
-  margin-bottom: 8px;
-}
-
-.staticSectionHead h2 { margin: 0; }
-
-.staticCount {
-  display: inline-block;
-  min-width: 22px;
-  padding: 1px 7px;
-  margin-left: 6px;
-  border-radius: 11px;
-  background: var(--danger);
-  color: #fff;
-  font-size: 12px;
-  text-align: center;
-}
-
-.staticBulkActions { display: flex; flex-wrap: wrap; gap: 8px; }
-.staticBulkActions button,
-.staticRowActions button { padding: 8px 12px; font-size: 13px; }
-
-.staticMissed .episodeRow { border-left: 3px solid var(--danger); }
-
-.staticCheck {
-  width: 18px;
-  height: 18px;
-  margin: 0;
-  flex-shrink: 0;
-  accent-color: var(--accent);
-}
-
-.staticRowActions { display: flex; flex-wrap: wrap; gap: 8px; flex-shrink: 0; }
-
-/* Group-progress list: what the group has seen fades back, the next item
-   stands out. */
-.episodeRow.isWatched { opacity: .55; }
-.episodeRow.isNext { outline: 2px solid var(--accent); }
-
-.staticState {
-  flex-shrink: 0;
-  font-size: 12px;
-  font-weight: 600;
-  color: var(--muted);
-  text-align: right;
-}
-
-.staticState .mine { display: block; color: var(--accent-bright); font-weight: 400; }
-.episodeRow.isNext .staticState { color: var(--accent-bright); }
-
-.staticMembers { display: flex; flex-wrap: wrap; gap: 8px; }
-
-.staticMember {
-  background: var(--bg-header);
-  border-radius: 16px;
-  padding: 6px 12px;
-  font-size: 13px;
-}
-
-.staticMember .hint { margin: 0 0 0 6px; font-size: 12px; }
-
-@media (max-width: 600px) {
-  .staticHeader { flex-direction: column; }
-  .staticCover { width: 120px; }
-  .staticRowActions { flex-basis: 100%; order: 4; }
-}

client/src/views/staticParty/StaticParty.html

@@ -1,39 +0,0 @@
-<button class="linklike" id="back">&larr; Retour</button>
-<div class="staticHeader">
-  <img class="staticCover" id="staticCover" alt="" loading="lazy" onerror="this.classList.add('noImage')" />
-  <div class="seriesInfo">
-    <span class="staticBadge">Lounge party</span>
-    <h1 id="staticTitle"></h1>
-    <p class="hint staticMeta" id="staticMeta"></p>
-    <div class="staticProgress" aria-hidden="true"><div class="staticProgressFill" id="staticProgressFill"></div></div>
-    <p class="staticNext" id="staticNext"></p>
-    <div class="staticActions">
-      <button id="sessionBtn">Lancer la séance</button>
-      <button class="secondaryBtn hide" id="joinBtn">Rejoindre cette lounge party</button>
-      <button class="linklike hide" id="leaveBtn">Quitter</button>
-      <button class="linklike hide" id="deleteBtn">Supprimer</button>
-    </div>
-  </div>
-</div>
-
-<section class="section staticMissed" id="missedSection" hidden>
-  <div class="staticSectionHead">
-    <h2>Tu as manqué <span class="staticCount" id="missedCount"></span></h2>
-    <div class="staticBulkActions">
-      <button class="secondaryBtn" id="catchUpSoloBtn">Rattraper en solo</button>
-      <button class="secondaryBtn" id="catchUpPartyBtn">Lancer une watch party de rattrapage</button>
-    </div>
-  </div>
-  <p class="hint">Décoche ce que tu ne veux pas rattraper tout de suite.</p>
-  <div class="episodeList" id="missedList"></div>
-</section>
-
-<section class="section">
-  <h2>Membres</h2>
-  <div class="staticMembers" id="memberList"></div>
-</section>
-
-<section class="section">
-  <h2>Progression du groupe</h2>
-  <div class="episodeList" id="itemList"></div>
-</section>

client/src/views/staticParty/StaticParty.ts

@@ -1,227 +0,0 @@
-import './StaticParty.css';
-import html from './StaticParty.html';
-import {
-  deleteStaticParty,
-  getStaticParty,
-  joinStaticParty,
-  leaveStaticParty,
-  markStaticItemWatched,
-  startCatchUp,
-  startStaticSession
-} from '../../api/staticParty';
-import { navigate } from '../../router';
-import type { RouteParams } from '../../router';
-import { escapeHtml } from '../../tiles';
-import { LOADING_HINT } from '../../loading';
-import { showToast } from '../../toast';
-import type { StaticPartyDetailDto, StaticPartyItemDto } from '../../types';
-
-/** How each lounge party source is named in the UI - shared with the
- *  "Lounge parties" tab (views/staticParties). */
-export const SOURCE_LABELS: Record<StaticPartyDetailDto['sourceType'], string> = {
-  series: 'Série',
-  season: 'Saison',
-  playlist: 'Playlist'
-};
-
-/**
- * Route `/static/:id` - one static (persistent) watch party: the group's
- * progress through the whole series/playlist, its members, and - the
- * point of the feature - what *you* missed, with ways to catch up (alone,
- * or as a watch party others can join) or mark things as already seen.
- * Launching the group's session hands off to the normal player
- * (`/party/:id`) - a session is an ordinary party server-side. See
- * server/src/services/StaticPartyService.ts and spec/static-watch-party.md.
- */
-export async function renderStaticParty(root: HTMLElement, params: RouteParams): Promise<void> {
-  const staticId = params.id as string;
-  root.innerHTML = LOADING_HINT;
-
-  let detail: StaticPartyDetailDto;
-  try {
-    detail = await getStaticParty(staticId);
-  } catch (err) {
-    console.error('[staticParty] load failed', staticId, err);
-    root.innerHTML = `<p class="error">${escapeHtml((err as Error).message || 'Impossible de charger cette lounge party.')}</p>`;
-    return;
-  }
-
-  root.innerHTML = html;
-  root.querySelector('#back')!.addEventListener('click', () => history.back());
-  wireActions(root, staticId);
-  render(root, detail);
-}
-
-/** Re-fetches and re-renders in place - after any action that changed
- *  progress or membership. */
-async function reload(root: HTMLElement, staticId: string): Promise<void> {
-  try {
-    const detail = await getStaticParty(staticId);
-    if (!root.querySelector('#staticTitle')) return; // navigated away mid-flight
-    render(root, detail);
-  } catch (err) {
-    console.error('[staticParty] reload failed', staticId, err);
-    showToast((err as Error).message, { variant: 'error' });
-  }
-}
-
-/** Fills every part of the page from `detail`. */
-function render(root: HTMLElement, detail: StaticPartyDetailDto): void {
-  (root.querySelector('#staticCover') as HTMLImageElement).src = detail.imageUrl;
-  root.querySelector('#staticTitle')!.textContent = detail.name;
-  const sourceLabel = SOURCE_LABELS[detail.sourceType];
-  root.querySelector('#staticMeta')!.textContent =
-    `${sourceLabel} · ${detail.groupWatchedCount}/${detail.itemCount} vus par le groupe · ${detail.memberCount} membre${detail.memberCount > 1 ? 's' : ''}`;
-  const percent = detail.itemCount ? Math.round((detail.groupWatchedCount / detail.itemCount) * 100) : 0;
-  (root.querySelector('#staticProgressFill') as HTMLElement).style.width = `${percent}%`;
-  root.querySelector('#staticNext')!.innerHTML = detail.nextItemName
-    ? `Prochain : <strong>${escapeHtml(detail.nextItemName)}</strong>`
-    : '<strong>Le groupe a tout vu.</strong>';
-
-  const sessionBtn = root.querySelector('#sessionBtn') as HTMLButtonElement;
-  sessionBtn.textContent = detail.livePartyId ? 'Rejoindre la séance en cours' : 'Lancer la séance';
-  sessionBtn.disabled = !detail.livePartyId && !detail.nextItemName;
-  root.querySelector('#joinBtn')!.classList.toggle('hide', detail.youAreMember);
-  root.querySelector('#leaveBtn')!.classList.toggle('hide', !detail.youAreMember || detail.youAreCreator);
-  root.querySelector('#deleteBtn')!.classList.toggle('hide', !detail.youAreCreator);
-
-  renderMissed(root, detail);
-  renderMembers(root, detail);
-  renderItems(root, detail);
-}
-
-/** "Tu as manqué" - hidden entirely when there's nothing to catch up on. */
-function renderMissed(root: HTMLElement, detail: StaticPartyDetailDto): void {
-  const section = root.querySelector('#missedSection') as HTMLElement;
-  const missed = new Set(detail.missedItemIds);
-  const items = detail.items.filter((i) => missed.has(i.itemId));
-  section.hidden = !items.length;
-  root.querySelector('#missedCount')!.textContent = String(items.length);
-  root.querySelector('#missedList')!.innerHTML = items.map((item) => `
-    <div class="episodeRow">
-      <input type="checkbox" class="staticCheck" data-item-id="${escapeHtml(item.itemId)}" checked aria-label="Inclure dans le rattrapage" />
-      <img src="${escapeHtml(item.itemImageUrl)}" alt="" loading="lazy" onerror="this.classList.add('noImage')" />
-      <div class="episodeInfo"><strong>${escapeHtml(item.itemName)}</strong></div>
-      <div class="staticRowActions">
-        <button class="secondaryBtn soloOneBtn" data-item-id="${escapeHtml(item.itemId)}">Regarder en solo</button>
-        <button class="secondaryBtn markWatchedBtn" data-item-id="${escapeHtml(item.itemId)}">Marquer comme vu</button>
-      </div>
-    </div>`).join('');
-}
-
-/** One chip per member, with how many items they've watched. */
-function renderMembers(root: HTMLElement, detail: StaticPartyDetailDto): void {
-  root.querySelector('#memberList')!.innerHTML = detail.members.length
-    ? detail.members.map((m) => `
-      <span class="staticMember">${escapeHtml(m.userName)}${m.isCreator ? ' ★' : ''}<span class="hint">${m.watchedCount}/${detail.itemCount}</span></span>`).join('')
-    : '<p class="hint">Aucun membre pour le moment.</p>';
-}
-
-/** The whole item list, with the group's state and the viewer's own. */
-function renderItems(root: HTMLElement, detail: StaticPartyDetailDto): void {
-  root.querySelector('#itemList')!.innerHTML = detail.items.map((item, i) => `
-    <div class="episodeRow${item.groupState === 'watched' ? ' isWatched' : ''}${item.groupState === 'next' ? ' isNext' : ''}">
-      <img src="${escapeHtml(item.itemImageUrl)}" alt="" loading="lazy" onerror="this.classList.add('noImage')" />
-      <div class="episodeInfo"><strong>${i + 1}. ${escapeHtml(item.itemName)}</strong></div>
-      <span class="staticState">${stateLabel(item)}${item.viewerWatched ? '<span class="mine">✓ vu par toi</span>' : ''}</span>
-    </div>`).join('');
-}
-
-/** The group-state label for one item. */
-function stateLabel(item: StaticPartyItemDto): string {
-  if (item.groupState === 'watched') return 'Vu par le groupe';
-  if (item.groupState === 'next') return 'Prochain';
-  return 'À venir';
-}
-
-/**
- * Wires every button once - lists are re-rendered on reload, so row
- * buttons use one delegated listener on their container rather than
- * per-row listeners re-added on every render.
- */
-function wireActions(root: HTMLElement, staticId: string): void {
-  const sessionBtn = root.querySelector('#sessionBtn') as HTMLButtonElement;
-  sessionBtn.addEventListener('click', () => {
-    runBusy(sessionBtn, async () => {
-      const { partyId } = await startStaticSession(staticId);
-      navigate(`/party/${partyId}`);
-    });
-  });
-
-  const joinBtn = root.querySelector('#joinBtn') as HTMLButtonElement;
-  joinBtn.addEventListener('click', () => {
-    runBusy(joinBtn, async () => {
-      await joinStaticParty(staticId);
-      showToast('Tu fais maintenant partie de cette lounge party.');
-      await reload(root, staticId);
-    });
-  });
-
-  const leaveBtn = root.querySelector('#leaveBtn') as HTMLButtonElement;
-  leaveBtn.addEventListener('click', () => {
-    if (!confirm('Quitter cette lounge party ? Ta progression y sera oubliée.')) return;
-    runBusy(leaveBtn, async () => {
-      await leaveStaticParty(staticId);
-      await reload(root, staticId);
-    });
-  });
-
-  const deleteBtn = root.querySelector('#deleteBtn') as HTMLButtonElement;
-  deleteBtn.addEventListener('click', () => {
-    if (!confirm('Supprimer cette lounge party pour tout le monde ? La progression de chacun sera perdue.')) return;
-    runBusy(deleteBtn, async () => {
-      await deleteStaticParty(staticId);
-      showToast('Lounge party supprimée.');
-      navigate('/static');
-    });
-  });
-
-  const catchUp = (btn: HTMLButtonElement, mode: 'solo' | 'party') => {
-    const itemIds = Array.from(root.querySelectorAll<HTMLInputElement>('#missedList .staticCheck'))
-      .filter((c) => c.checked)
-      .map((c) => c.dataset.itemId as string);
-    if (!itemIds.length) {
-      showToast('Coche au moins un élément à rattraper.', { variant: 'error' });
-      return;
-    }
-    runBusy(btn, async () => {
-      const { partyId } = await startCatchUp(staticId, itemIds, mode);
-      navigate(`/party/${partyId}`);
-    });
-  };
-  const soloBtn = root.querySelector('#catchUpSoloBtn') as HTMLButtonElement;
-  const partyBtn = root.querySelector('#catchUpPartyBtn') as HTMLButtonElement;
-  soloBtn.addEventListener('click', () => catchUp(soloBtn, 'solo'));
-  partyBtn.addEventListener('click', () => catchUp(partyBtn, 'party'));
-
-  root.querySelector('#missedList')!.addEventListener('click', (e) => {
-    const btn = (e.target as HTMLElement).closest<HTMLButtonElement>('button[data-item-id]');
-    if (!btn) return;
-    const itemId = btn.dataset.itemId as string;
-    if (btn.classList.contains('soloOneBtn')) {
-      runBusy(btn, async () => {
-        const { partyId } = await startCatchUp(staticId, [itemId], 'solo');
-        navigate(`/party/${partyId}`);
-      });
-    } else if (btn.classList.contains('markWatchedBtn')) {
-      runBusy(btn, async () => {
-        await markStaticItemWatched(staticId, itemId);
-        await reload(root, staticId);
-      });
-    }
-  });
-}
-
-/** Disables `btn` while `action` runs; a failure is toasted, logged, and
- *  gives the button back. */
-function runBusy(btn: HTMLButtonElement, action: () => Promise<void>): void {
-  btn.disabled = true;
-  action()
-    .catch((err: unknown) => {
-      console.error('[staticParty] action failed', err);
-      showToast((err as Error).message, { variant: 'error' });
-    })
-    .finally(() => {
-      btn.disabled = false;
-    });
-}

client/src/views/staticParty/createStaticButton.ts

@@ -1,31 +0,0 @@
-import { createStaticParty } from '../../api/staticParty';
-import { navigate } from '../../router';
-import { showToast } from '../../toast';
-
-/**
- * "Créer une lounge party" - shared by views/series (whole series, or
- * the selected season) and views/playlist: creates a lounge party over
- * the source id (a series, a season or a video playlist - the server
- * decides which, and refuses anything else with a message) and opens its
- * page. `sourceId` is read at click time, so a caller whose source can
- * change (the selected season tab) wires the button only once.
- */
-export function wireCreateStaticButton(btn: HTMLButtonElement, getSourceId: () => string): void {
-  const idleLabel = btn.textContent || '';
-  btn.addEventListener('click', () => {
-    const sourceId = getSourceId();
-    btn.disabled = true;
-    btn.textContent = 'Création...';
-    createStaticParty(sourceId)
-      .then((sp) => {
-        console.info('[staticParty] created', sp.id, 'from', sourceId);
-        navigate(`/static/${sp.id}`);
-      })
-      .catch((err: unknown) => {
-        console.error('[staticParty] create failed', sourceId, err);
-        showToast((err as Error).message, { variant: 'error' });
-        btn.disabled = false;
-        btn.textContent = idleLabel;
-      });
-  });
-}

docker-compose.yml

@@ -8,9 +8,3 @@ services:
       - "3000:3000"
     environment:
       EMBY_SERVER_URL: "https://theater.media.kyuno.fr"
-      # Static (persistent) watch parties are saved here - see
-      # server/src/services/StaticPartyStore.ts. Without the volume below
-      # they'd be lost every time the container is recreated.
-      DATA_DIR: "/data"
-    volumes:
-      - ./data:/data

docs/architecture.md

@@ -851,23 +851,6 @@ player against the new `itemId` on that message. A movie or a
 standalone-started episode just gets a one-item queue, so this is a strict
 superset of the old single-item behavior, not a separate code path.
 
-**Later: a whole series or one season, not just "from this episode".**
-`POST /api/parties` also accepts a `Series` id and a `Season` id, not
-only an episode.
-
-- **Series**: queues every season from S1E1. Specials (season 0) sort
-  first in Emby's list and are left out, so launching the whole series
-  builds the same queue as clicking S1E1. This is the pure
-  `CatalogService.seriesQueueFrom`, which the episode path now uses too.
-- **Season**: queues only that season's episodes
-  (`CatalogService.seasonQueue`).
-- **Where it's launched from**: the series page's "Lancer toute la
-  série" / "Lancer cette saison" buttons. A series tile in a library
-  also gets the normal "Lancer une watch party" button: `Series` joined
-  `WATCH_PARTY_TYPES`.
-- **Lounge parties** take the same two sources (a whole series or one
-  season). See spec/static-watch-party.md.
-
 ### Player: language, subtitles, quality
 
 `GET /api/catalog/item/:id/playback-options` reads `PlaybackInfo`'s
@@ -4579,43 +4562,6 @@ would have overflowed by well over 200px. A separate portrait check
 (375x700) confirmed this landscape block changes nothing there: still
 `column`, still the original 220px `vw`-capped art, unaffected.
 
-## Static (persistent) watch parties
-
-Asked for directly: a watch party built from a whole series or video
-playlist that remembers the group's progress *and* each person's, so
-someone coming back or joining late sees what they missed. Full design
-in [`spec/static-watch-party.md`](../spec/static-watch-party.md). The
-short version:
-
-- **A new persistent entity, not a change to Party.**
-  `StaticPartyService` owns the group and member progress. Each session
-  is an ordinary live `Party` linked back through `party.staticLink`,
-  so the player, sync, shared stream, lobby and host handoff are all
-  reused unchanged. `PartyService` calls into `StaticPartyService`,
-  never the other way around.
-- **This app's first on-disk state.** One JSON file per static party
-  (`StaticPartyStore`, `${DATA_DIR}/static-parties/<id>.json`). Writes
-  are atomic, debounced per party, and flushed on SIGTERM. It started
-  as a single file for every party; that was split, so a write only
-  touches the party that changed and a corrupt file costs only that
-  party. The old single file is migrated once, on first load. "Party
-  lifecycle" above still holds for ordinary parties.
-- **Its own tab and its own name.** The UI calls these **Lounge
-  parties**, next to **Watch party** (classic video) and **Listen
-  party** (classic audio). The code keeps "static party". The "Lounge
-  parties" tab (`/static`) lists them. The home page's live "Parties en
-  cours" list (each card badged Watch/Listen party) leaves their
-  sessions out, so classic and lounge parties never share a list.
-- **"Completed" gained a second trigger.** `PartyService
-  .completeCurrentItem` is now the one place an item counts as done. It
-  handles Emby Played, as before, plus static progress. It runs from
-  `advanceQueue`, and from a new host-only `"itemEnded"` socket event
-  for the *last* queued item. That item was previously never marked
-  Played at all, since there was no "next" to send for it.
-- **Missed = group-completed − watched in-app − Emby Played**, computed
-  by the pure `computeMissedIds`. Each viewer's own Emby `UserData` is
-  read from the source re-fetch under their own session.
-
 ## Known limitations
 
 - Playback always goes through `hls.js` against whatever Emby's
@@ -4632,10 +4578,7 @@ short version:
   resume), so two listeners' `<audio>` elements could drift apart slightly
   during a long stretch with no such event - accepted for v1 given music's
   more forgiving tolerance for exact sync compared to video+subtitles.
-- No persistence for ordinary parties: server restart or long idle time
+- No persistence: server restart or long idle time ends every party.
-  ends every one. Only static watch parties (see their own section) are
-  persisted - and even their live sessions end on a restart, resuming
-  from the last saved position.
 - No free seeking within a music track (only vote-skip to the *next* one)
   - not asked for, and would need its own protocol addition
   (`MusicQueueService` has no notion of "jump to position X" today, only

server/Dockerfile

@@ -46,10 +46,6 @@ COPY --from=build /app/client/dist ./client/dist
 
 WORKDIR /app/server
 ENV PORT=3000
-# Static watch parties' JSON file (StaticPartyStore) - mount a volume here
-# (docker-compose.yml does), or they're lost with the container.
-ENV DATA_DIR=/data
-RUN mkdir -p /data
 EXPOSE 3000
 
 CMD ["node", "dist/index.js"]

server/package.json

@@ -9,7 +9,7 @@
     "start": "node dist/index.js",
     "dev": "tsx watch src/index.ts",
     "typecheck": "tsc -p tsconfig.test.json",
-    "test": "tsx --test test/castTokenService.test.ts test/catalogService.test.ts test/embyClient.test.ts test/embySessionService.test.ts test/musicQueueService.test.ts test/partyService.test.ts test/partyStreamService.test.ts test/playstateService.test.ts test/socketGateway.test.ts test/staticPartyService.test.ts test/transcodeService.test.ts"
+    "test": "tsx --test test/castTokenService.test.ts test/catalogService.test.ts test/embyClient.test.ts test/embySessionService.test.ts test/musicQueueService.test.ts test/partyService.test.ts test/partyStreamService.test.ts test/playstateService.test.ts test/socketGateway.test.ts test/transcodeService.test.ts"
   },
   "engines": {
     "node": ">=18"

server/src/Logger.ts

@@ -83,11 +83,4 @@ export class Logger {
   static playstate(message: string): void {
     console.log(`[watchparty:playstate] ${new Date().toISOString()} ${message}`);
   }
-
-  /** Static (persistent) watch parties - created/joined/left/deleted,
-   *  group and per-member progress, sessions launched, and every load/save
-   *  of their JSON file (see StaticPartyService/StaticPartyStore). */
-  static staticParty(message: string): void {
-    console.log(`[watchparty:static] ${new Date().toISOString()} ${message}`);
-  }
 }

server/src/config.ts

@@ -17,11 +17,3 @@ if (!EMBY_SERVER_URL) {
 }
 
 export const PORT = Number(process.env.PORT) || 3000;
-
-/**
- * Where persistent state lives on disk - today only the static watch
- * parties (see StaticPartyStore). Relative paths resolve against the
- * process's working directory. Mount a volume here in Docker, or every
- * static watch party is lost with the container.
- */
-export const DATA_DIR = process.env.DATA_DIR || './data';

server/src/index.ts

@@ -5,10 +5,10 @@ import http from 'http';
 import express, { type NextFunction, type Request, type Response } from 'express';
 import { Server as SocketIoServer } from 'socket.io';
 
-import { DATA_DIR, EMBY_SERVER_URL, PORT } from './config';
+import { EMBY_SERVER_URL, PORT } from './config';
 import { Logger } from './Logger';
 import { AuthService, SESSION_COOKIE, SESSION_TTL_MS } from './services/AuthService';
-import { CatalogService, CatalogFetchError, imageUrlFor, seasonQueue, seriesQueueFrom, splitPlaylistByMediaType } from './services/CatalogService';
+import { CatalogService, CatalogFetchError, imageUrlFor, splitPlaylistByMediaType } from './services/CatalogService';
 import { PartyService } from './services/PartyService';
 import { MusicQueueService } from './services/MusicQueueService';
 import { TranscodeService } from './services/TranscodeService';
@@ -16,13 +16,8 @@ import { PartyStreamService } from './services/PartyStreamService';
 import { PlaystateService } from './services/PlaystateService';
 import { EmbySessionService } from './services/EmbySessionService';
 import { CastTokenService } from './services/CastTokenService';
-import { StaticPartyService } from './services/StaticPartyService';
-import { StaticPartyStore } from './services/StaticPartyStore';
 import { SocketGateway } from './realtime/SocketGateway';
-import type { ClientToServerEvents, EmbyItem, EmbySession, ItemDto, MediaType, MusicTrackInput, QueueItem, ServerToClientEvents, StaticParty } from './types';
+import type { ClientToServerEvents, EmbyItem, EmbySession, ItemDto, MediaType, MusicTrackInput, QueueItem, ServerToClientEvents } from './types';
-
-StaticPartyStore.configure(DATA_DIR);
-StaticPartyService.init();
 
 const app = express();
 app.set('trust proxy', 1); // behind openresty/nginx - needed for req.secure to reflect the real scheme
@@ -258,7 +253,7 @@ app.get('/api/catalog/party-stream/:partyId/master.m3u8', allowCastCors, asyncRo
   if (!session) { res.status(401).end(); return; }
   const party = PartyService.getById(partyId);
   if (!party || !party.members.has(session.userId)) {
-    res.status(403).json({ error: "Tu n'es pas membre de cette party." });
+    res.status(403).json({ error: "Tu n'es pas membre de cette watch party." });
     return;
   }
   await PartyStreamService.serveMasterPlaylist(req, res, party, session);
@@ -272,7 +267,7 @@ app.get('/api/catalog/party-stream/:partyId/raw', allowCastCors, asyncRoute(asyn
   if (!session) { res.status(401).end(); return; }
   const party = PartyService.getById(partyId);
   if (!party || !party.members.has(session.userId)) {
-    res.status(403).json({ error: "Tu n'es pas membre de cette party." });
+    res.status(403).json({ error: "Tu n'es pas membre de cette watch party." });
     return;
   }
   await PartyStreamService.serveRawAsset(req, res, party, session);
@@ -302,7 +297,7 @@ app.get('/api/catalog/burn/:partyId/master.m3u8', allowCastCors, asyncRoute(asyn
   if (!session) { res.status(401).end(); return; }
   const party = PartyService.getById(partyId);
   if (!party || !party.members.has(session.userId)) {
-    res.status(403).json({ error: "Tu n'es pas membre de cette party." });
+    res.status(403).json({ error: "Tu n'es pas membre de cette watch party." });
     return;
   }
   if (!party.burnInSubtitleIndex) {
@@ -318,7 +313,7 @@ app.get('/api/catalog/burn/:partyId/:segment', allowCastCors, asyncRoute(async (
   if (!session) { res.status(401).end(); return; }
   const party = PartyService.getById(partyId);
   if (!party || !party.members.has(session.userId)) {
-    res.status(403).json({ error: "Tu n'es pas membre de cette party." });
+    res.status(403).json({ error: "Tu n'es pas membre de cette watch party." });
     return;
   }
   await TranscodeService.serveSegment(req, res, party, param(req, 'segment'));
@@ -356,20 +351,6 @@ app.post('/api/parties', requireSession, asyncRoute(async (req, res) => {
   // resolveMusicTracksForItem). Asked for directly, alongside the same
   // action on the party's own existing queue - see the "queue" route
   // below - both share this resolution.
-  // A whole series - every season, in order, from S1E1 (see
-  // seriesQueueFrom). Launched from the series page's own button or its
-  // library tile; an episode's own button still starts from that episode
-  // (the Episode branch below).
-  if (item.Type === 'Series') {
-    await createPartyFromSeries(res, session, item);
-    return;
-  }
-  // Just one season - the series page's per-season button (see seasonQueue).
-  if (item.Type === 'Season') {
-    await createPartyFromSeason(res, session, item);
-    return;
-  }
-
   if (item.Type === 'MusicAlbum' || item.Type === 'MusicArtist') {
     const tracks = await resolveMusicTracksForItem(session, item);
     createMusicPartyFromTracks(res, session, tracks);
@@ -386,8 +367,13 @@ app.post('/api/parties', requireSession, asyncRoute(async (req, res) => {
   let queue: QueueItem[] | null = null;
   if (mediaType === 'video' && item.Type === 'Episode' && item.SeriesId) {
     const all = await CatalogService.getAllSeriesEpisodesRaw(session, item.SeriesId);
-    const remaining = seriesQueueFrom(all, itemId);
+    const startIndex = all.findIndex((e) => e.Id === itemId);
-    queue = (remaining.length ? remaining : [item]).map(toVideoQueueItem);
+    const remaining = startIndex >= 0 ? all.slice(startIndex) : [item];
+    queue = remaining.map((e) => ({
+      itemId: e.Id,
+      itemName: formatEpisodeName(e),
+      itemImageUrl: `/api/catalog/image/${e.Id}`
+    }));
   }
 
   const party = PartyService.create(
@@ -424,17 +410,6 @@ function formatEpisodeName(episode: { ParentIndexNumber?: number; IndexNumber?:
   return episode.Name;
 }
 
-/** One video item (episode or movie) as a queue entry - shared by every
- *  path that builds a video queue: an episode's series, a playlist, a
- *  static watch party. */
-function toVideoQueueItem(item: EmbyItem): QueueItem {
-  return {
-    itemId: item.Id,
-    itemName: item.Type === 'Episode' ? formatEpisodeName(item) : item.Name,
-    itemImageUrl: `/api/catalog/image/${item.Id}`
-  };
-}
-
 /**
  * The "launch this playlist" half of POST /api/parties above - kept
  * separate rather than merged into the single-item path, which is
@@ -481,7 +456,11 @@ async function createPartyFromPlaylist(res: Response, session: EmbySession, play
     return;
   }
 
-  const queue: QueueItem[] = items.map(toVideoQueueItem);
+  const queue: QueueItem[] = items.map((e) => ({
+    itemId: e.Id,
+    itemName: e.Type === 'Episode' ? formatEpisodeName(e) : e.Name,
+    itemImageUrl: `/api/catalog/image/${e.Id}`
+  }));
   const party = PartyService.create(
     session.userId, session.userName,
     queue[0]!.itemId, queue[0]!.itemName, queue[0]!.itemImageUrl,
@@ -492,45 +471,6 @@ async function createPartyFromPlaylist(res: Response, session: EmbySession, play
   res.json(PartyService.toPublicState(party, session.userId));
 }
 
-/** The "launch the whole series" half of POST /api/parties - a watch
- *  party queued with every episode of every season (see seriesQueueFrom). */
-async function createPartyFromSeries(res: Response, session: EmbySession, series: EmbyItem): Promise<void> {
-  const episodes = await CatalogService.getAllSeriesEpisodesRaw(session, series.Id);
-  const queue = seriesQueueFrom(episodes).map(toVideoQueueItem);
-  if (!queue.length) {
-    res.status(400).json({ error: "Cette série n'a aucun épisode." });
-    return;
-  }
-  createVideoPartyFromQueue(res, session, queue, `series="${series.Name}"`);
-}
-
-/** The "launch just this season" half of POST /api/parties - only that
- *  season's episodes, nothing after it (see seasonQueue). */
-async function createPartyFromSeason(res: Response, session: EmbySession, season: EmbyItem): Promise<void> {
-  if (!season.SeriesId) {
-    res.status(400).json({ error: 'Saison introuvable.' });
-    return;
-  }
-  const episodes = await CatalogService.getAllSeriesEpisodesRaw(session, season.SeriesId);
-  const queue = seasonQueue(episodes, season).map(toVideoQueueItem);
-  if (!queue.length) {
-    res.status(400).json({ error: "Cette saison n'a aucun épisode." });
-    return;
-  }
-  createVideoPartyFromQueue(res, session, queue, `season="${season.Name}" series=${season.SeriesId}`);
-}
-
-/** Creates a video watch party playing `queue` in order, hosted by
- *  `session` - shared by the whole-series and single-season launches. */
-function createVideoPartyFromQueue(res: Response, session: EmbySession, queue: QueueItem[], logContext: string): void {
-  const first = queue[0]!;
-  const party = PartyService.create(session.userId, session.userName, first.itemId, first.itemName, first.itemImageUrl, queue, 'video');
-  PartyService.setMemberEmbyToken(party, session.userId, session.embyToken);
-  Logger.party(`queue launch partyId=${party.id} ${logContext} episodes=${queue.length}`);
-  SocketGateway.broadcastLobby(io);
-  res.json(PartyService.toPublicState(party, session.userId));
-}
-
 /** A raw Emby item known/expected to be music-shaped (Audio, MusicAlbum,
  *  or MusicArtist - the three POST /api/parties and the "queue" route
  *  below ever call this for) resolved into a flat, ordered track list -
@@ -608,12 +548,12 @@ function createMusicPartyFromTracks(res: Response, session: EmbySession, tracks:
 app.post('/api/parties/:partyId/tracks', requireSession, (req, res) => {
   const party = PartyService.getById(param(req, 'partyId'));
   if (!party || party.mediaType !== 'music') {
-    res.status(404).json({ error: 'Listen party introuvable.' });
+    res.status(404).json({ error: 'Watch party musique introuvable.' });
     return;
   }
   const session = req.embySession!;
   if (!party.members.has(session.userId)) {
-    res.status(403).json({ error: "Tu n'es pas membre de cette party." });
+    res.status(403).json({ error: "Tu n'es pas membre de cette watch party." });
     return;
   }
   const track = req.body || {};
@@ -639,12 +579,12 @@ app.post('/api/parties/:partyId/tracks', requireSession, (req, res) => {
 app.post('/api/parties/:partyId/queue', requireSession, asyncRoute(async (req, res) => {
   const party = PartyService.getById(param(req, 'partyId'));
   if (!party || party.mediaType !== 'music') {
-    res.status(404).json({ error: 'Listen party introuvable.' });
+    res.status(404).json({ error: 'Watch party musique introuvable.' });
     return;
   }
   const session = req.embySession!;
   if (!party.members.has(session.userId)) {
-    res.status(403).json({ error: "Tu n'es pas membre de cette party." });
+    res.status(403).json({ error: "Tu n'es pas membre de cette watch party." });
     return;
   }
   const itemId = req.body?.itemId;
@@ -668,12 +608,6 @@ app.post('/api/parties/:partyId/join', requireSession, (req, res) => {
   const session = req.embySession!;
   PartyService.join(party, session.userId, session.userName);
   PartyService.setMemberEmbyToken(party, session.userId, session.embyToken);
-  // Joining a static watch party's group session from the lobby makes you
-  // a member of that static party too - its progress is now yours.
-  if (party.staticLink?.mode === 'group') {
-    const sp = StaticPartyService.getById(party.staticLink.staticPartyId);
-    if (sp) StaticPartyService.join(sp, { userId: session.userId, userName: session.userName });
-  }
   SocketGateway.broadcastLobby(io); // member count changed - reflect it on the home page immediately
   res.json(PartyService.toPublicState(party, session.userId));
 });
@@ -714,7 +648,7 @@ app.post('/api/parties/:partyId/cast-token', requireSession, (req, res) => {
   const party = PartyService.getById(param(req, 'partyId'));
   const session = req.embySession!;
   if (!party || !party.members.has(session.userId)) {
-    res.status(403).json({ error: "Tu n'es pas membre de cette party." });
+    res.status(403).json({ error: "Tu n'es pas membre de cette watch party." });
     return;
   }
   res.json({ token: CastTokenService.issue(party.id, session) });
@@ -728,229 +662,6 @@ app.delete('/api/parties/:partyId/cast-token', requireSession, (req, res) => {
   res.json({ ok: true });
 });
 
-// --- Static (persistent) watch parties ------------------------------------
-// A whole series/video playlist watched by a group over several sessions,
-// remembering the group's progress and each member's - see
-// StaticPartyService and spec/static-watch-party.md. Each session is an
-// ordinary live party (PartyService) linked back through party.staticLink.
-
-/** Fetches a static party's source under `session`'s own account - so
- *  each item carries *their* Emby UserData (Played): the whole series
- *  from S1E1 (specials left out - see seriesQueueFrom), one season's
- *  episodes, or a playlist's video items. */
-async function fetchStaticSourceItems(session: EmbySession, source: StaticParty['source']): Promise<EmbyItem[]> {
-  if (source.type === 'series') {
-    return seriesQueueFrom(await CatalogService.getAllSeriesEpisodesRaw(session, source.sourceId));
-  }
-  if (source.type === 'season') {
-    if (!source.seriesId) return [];
-    const episodes = await CatalogService.getAllSeriesEpisodesRaw(session, source.seriesId);
-    return seasonQueue(episodes, { Id: source.sourceId, IndexNumber: source.seasonNumber });
-  }
-  const { mediaType, items } = splitPlaylistByMediaType(await CatalogService.getPlaylistItemsRaw(session, source.sourceId));
-  return mediaType === 'video' ? items : [];
-}
-
-/**
- * Re-fetches `sp`'s source for `session`: merges any new item into it
- * (StaticPartyService.refreshItems) and returns the ids Emby already has
- * as Played for this user. Best-effort - Emby being unreachable must not
- * make the page unusable, so a failure is logged and treated as "no
- * Played info, no new items" (the in-app progress still works on its own).
- */
-async function syncStaticSource(session: EmbySession, sp: StaticParty): Promise<Set<string>> {
-  try {
-    const raw = await fetchStaticSourceItems(session, sp.source);
-    StaticPartyService.refreshItems(sp, raw.map(toVideoQueueItem));
-    return new Set(raw.filter((i) => i.UserData?.Played).map((i) => i.Id));
-  } catch (err) {
-    Logger.staticParty(`source sync failed id=${sp.id} user=${Logger.who(session.userId, session.userName)}: ${(err as Error).message}`);
-    return new Set();
-  }
-}
-
-/** `sp`'s live group session id, if that party is still running - clears a
- *  stale one (a party can end without its static party having heard). */
-function liveGroupPartyId(sp: StaticParty): string | null {
-  if (sp.livePartyId && !PartyService.getById(sp.livePartyId)) StaticPartyService.setLiveParty(sp, null);
-  return sp.livePartyId;
-}
-
-/** Finds `:staticId` or answers 404 - null means the response is sent. */
-function staticPartyOr404(req: Request, res: Response): StaticParty | null {
-  const sp = StaticPartyService.getById(param(req, 'staticId'));
-  if (!sp) res.status(404).json({ error: 'Lounge party introuvable.' });
-  return sp;
-}
-
-app.get('/api/static-parties', requireSession, asyncRoute(async (req, res) => {
-  const session = req.embySession!;
-  const parties = StaticPartyService.list();
-  const played = await Promise.all(parties.map((sp) => syncStaticSource(session, sp)));
-  res.json({
-    staticParties: parties.map((sp, i) => StaticPartyService.toSummary(sp, session.userId, played[i]!, liveGroupPartyId(sp)))
-  });
-}));
-
-app.post('/api/static-parties', requireSession, asyncRoute(async (req, res) => {
-  const sourceId = req.body?.sourceId;
-  if (!sourceId || typeof sourceId !== 'string') {
-    res.status(400).json({ error: 'sourceId is required.' });
-    return;
-  }
-  const session = req.embySession!;
-  const item = await CatalogService.getRawItem(session, sourceId);
-
-  // A whole series, one season of it, or a video playlist. An episode
-  // stands for its whole series - the natural entry point from
-  // views/series is the series itself, but nothing's lost accepting one.
-  // `sourceItem` is what gives the default name and the artwork: the
-  // series itself for a season (a season's own poster is often missing).
-  let source: StaticParty['source'];
-  let sourceItem = item;
-  let defaultName = item.Name;
-  if (item.Type === 'Series') {
-    source = { type: 'series', sourceId: item.Id };
-  } else if (item.Type === 'Season' && item.SeriesId) {
-    source = { type: 'season', sourceId: item.Id, seriesId: item.SeriesId, seasonNumber: item.IndexNumber };
-    sourceItem = await CatalogService.getRawItem(session, item.SeriesId);
-    defaultName = `${sourceItem.Name} - ${item.Name}`;
-  } else if (item.Type === 'Episode' && item.SeriesId) {
-    source = { type: 'series', sourceId: item.SeriesId };
-    sourceItem = await CatalogService.getRawItem(session, item.SeriesId);
-    defaultName = sourceItem.Name;
-  } else if (item.Type === 'Playlist') {
-    source = { type: 'playlist', sourceId: item.Id };
-  } else {
-    res.status(400).json({ error: 'Une lounge party se crée depuis une série, une saison ou une playlist vidéo.' });
-    return;
-  }
-
-  const raw = await fetchStaticSourceItems(session, source);
-  if (!raw.length) {
-    const emptyMessages = { series: "Cette série n'a aucun épisode.", season: "Cette saison n'a aucun épisode.", playlist: 'Cette playlist ne contient aucune vidéo.' };
-    res.status(400).json({ error: emptyMessages[source.type] });
-    return;
-  }
-  const name = typeof req.body?.name === 'string' && req.body.name.trim() ? req.body.name.trim() : defaultName;
-  const sp = StaticPartyService.create(
-    { userId: session.userId, userName: session.userName },
-    source, name, imageUrlFor(sourceItem), raw.map(toVideoQueueItem)
-  );
-  const played = new Set(raw.filter((i) => i.UserData?.Played).map((i) => i.Id));
-  res.json(StaticPartyService.toDetail(sp, session.userId, played, null));
-}));
-
-app.get('/api/static-parties/:staticId', requireSession, asyncRoute(async (req, res) => {
-  const sp = staticPartyOr404(req, res);
-  if (!sp) return;
-  const session = req.embySession!;
-  const played = await syncStaticSource(session, sp);
-  res.json(StaticPartyService.toDetail(sp, session.userId, played, liveGroupPartyId(sp)));
-}));
-
-app.post('/api/static-parties/:staticId/join', requireSession, (req, res) => {
-  const sp = staticPartyOr404(req, res);
-  if (!sp) return;
-  const session = req.embySession!;
-  StaticPartyService.join(sp, { userId: session.userId, userName: session.userName });
-  res.json({ ok: true });
-});
-
-app.post('/api/static-parties/:staticId/leave', requireSession, (req, res) => {
-  const sp = staticPartyOr404(req, res);
-  if (!sp) return;
-  StaticPartyService.leave(sp, req.embySession!.userId);
-  res.json({ ok: true });
-});
-
-app.delete('/api/static-parties/:staticId', requireSession, (req, res) => {
-  const sp = staticPartyOr404(req, res);
-  if (!sp) return;
-  if (!StaticPartyService.delete(sp, req.embySession!.userId)) {
-    res.status(403).json({ error: 'Seule la personne qui a créé cette lounge party peut la supprimer.' });
-    return;
-  }
-  res.json({ ok: true });
-});
-
-app.post('/api/static-parties/:staticId/items/:itemId/watched', requireSession, (req, res) => {
-  const sp = staticPartyOr404(req, res);
-  if (!sp) return;
-  const session = req.embySession!;
-  if (!StaticPartyService.markWatched(sp, { userId: session.userId, userName: session.userName }, param(req, 'itemId'))) {
-    res.status(404).json({ error: 'Cet élément ne fait pas partie de cette lounge party.' });
-    return;
-  }
-  res.json({ ok: true });
-});
-
-// Launches the group's next session - or joins it, if one's already
-// running. Whoever launches it hosts it (see PartyService.create), and it
-// resumes exactly where the group stopped last time: the host's starting
-// position is seeded from the saved one, which is what Player.ts already
-// reads to place every member's first frame (see its init()).
-app.post('/api/static-parties/:staticId/session', requireSession, asyncRoute(async (req, res) => {
-  const sp = staticPartyOr404(req, res);
-  if (!sp) return;
-  const session = req.embySession!;
-  const who = { userId: session.userId, userName: session.userName };
-
-  const existingId = liveGroupPartyId(sp);
-  if (!existingId) await syncStaticSource(session, sp); // pick up new episodes before building the queue
-  // Checked again after the await: someone else may have launched it meanwhile.
-  const liveId = liveGroupPartyId(sp);
-  const live = liveId ? PartyService.getById(liveId) : null;
-  if (live) {
-    PartyService.join(live, session.userId, session.userName);
-    PartyService.setMemberEmbyToken(live, session.userId, session.embyToken);
-    StaticPartyService.join(sp, who);
-    SocketGateway.broadcastLobby(io);
-    res.json({ partyId: live.id });
-    return;
-  }
-
-  const queue = StaticPartyService.groupQueue(sp);
-  if (!queue.length) {
-    res.status(409).json({ error: 'Le groupe a déjà tout vu dans cette lounge party.' });
-    return;
-  }
-  const first = queue[0]!;
-  const party = PartyService.create(session.userId, session.userName, first.itemId, first.itemName, first.itemImageUrl, queue, 'video');
-  party.staticLink = { staticPartyId: sp.id, mode: 'group' };
-  party.members.get(session.userId)!.positionTicks = sp.group.resumePositionTicks;
-  PartyService.setMemberEmbyToken(party, session.userId, session.embyToken);
-  StaticPartyService.join(sp, who);
-  StaticPartyService.setLiveParty(sp, party.id);
-  SocketGateway.broadcastLobby(io);
-  res.json({ partyId: party.id });
-}));
-
-// Catching up on missed items - alone (a party hidden from the lobby) or as
-// an ordinary watch party others can join. Only the participants' own
-// progress changes; the group's doesn't (see StaticPartyService.onItemCompleted).
-app.post('/api/static-parties/:staticId/catch-up', requireSession, (req, res) => {
-  const sp = staticPartyOr404(req, res);
-  if (!sp) return;
-  const session = req.embySession!;
-  const mode = req.body?.mode === 'party' ? 'party' : 'solo';
-  const requested = new Set(Array.isArray(req.body?.itemIds) ? req.body.itemIds.filter((id: unknown) => typeof id === 'string') : []);
-  const queue = sp.items.filter((i) => requested.has(i.itemId)); // the static party's own order, never the caller's
-  if (!queue.length) {
-    res.status(400).json({ error: 'Aucun élément à rattraper.' });
-    return;
-  }
-  const first = queue[0]!;
-  const party = PartyService.create(session.userId, session.userName, first.itemId, first.itemName, first.itemImageUrl, queue, 'video');
-  party.staticLink = { staticPartyId: sp.id, mode: 'catchUp' };
-  party.hiddenFromLobby = mode === 'solo';
-  PartyService.setMemberEmbyToken(party, session.userId, session.embyToken);
-  StaticPartyService.join(sp, { userId: session.userId, userName: session.userName });
-  Logger.staticParty(`catch-up started id=${sp.id} mode=${mode} partyId=${party.id} items=${queue.length} by=${Logger.who(session.userId, session.userName)}`);
-  if (!party.hiddenFromLobby) SocketGateway.broadcastLobby(io);
-  res.json({ partyId: party.id });
-});
-
 // Catches whatever asyncRoute() forwarded (or a synchronous throw) -
 // CatalogFetchError carries its own status/message; anything else is an
 // unexpected bug, logged in full server-side but never leaked to the
@@ -1019,9 +730,6 @@ setInterval(() => {
   for (const party of PartyService.listActive()) {
     const state = PartyService.getCurrentPlaybackState(party);
     if (!state) continue; // nothing currently playing (e.g. an empty music queue)
-    // A static watch party's group session: remember where the group is,
-    // so the next session resumes there (no-op for any other party).
-    if (party.staticLink) StaticPartyService.recordPosition(party.staticLink, state.itemId, state.positionTicks);
     for (const member of party.members.values()) {
       if (!member.connection || !member.embyToken) continue;
       PlaystateService.updatePosition(member.embyToken, member.userId, state.itemId, state.positionTicks);
@@ -1058,16 +766,6 @@ setInterval(() => {
   }
 }, 20 * 1000);
 
-// A pending (debounced) static-party save must reach disk before the
-// process exits - `docker stop` sends SIGTERM, Ctrl+C sends SIGINT.
-for (const signal of ['SIGTERM', 'SIGINT'] as const) {
-  process.once(signal, () => {
-    Logger.staticParty(`${signal} received - flushing before exit`);
-    StaticPartyStore.flushSync();
-    process.exit(0);
-  });
-}
-
 server.listen(PORT, () => {
   console.log(`[watchparty] listening on :${PORT} (Emby server: ${EMBY_SERVER_URL || 'NOT SET'})`);
 });

server/src/realtime/SocketGateway.ts

@@ -3,7 +3,6 @@
 import { Logger } from '../Logger';
 import { MusicQueueService } from '../services/MusicQueueService';
 import { PartyService } from '../services/PartyService';
-import { StaticPartyService } from '../services/StaticPartyService';
 import type { AppServer, LeaveResult, LobbyPartyDto, Party, SocketMemberDto } from '../types';
 
 /**
@@ -36,9 +35,6 @@ import type { AppServer, LeaveResult, LobbyPartyDto, Party, SocketMemberDto } fr
  *   "playstate" {isPaused, positionTicks}   (host only - ignored otherwise)
  *   "playstate" (server -> client, to everyone in the party but the sender)
  *   "next"                                  (host only - advance the queue)
- *   "itemEnded"                             (host only - the last queued item
- *                                            played to its end; counts it as
- *                                            completed without advancing)
  *   "itemChanged" (server -> client)
  *   "setBurnInSubtitle" {subtitleIndex, audioIndex?}  (host only - picks
  *     or clears the party's *shared* self-hosted-ffmpeg burn-in stream,
@@ -211,17 +207,6 @@ class SocketGatewayClass {
         }
       }));
 
-      // The last queued item played to its end - nothing to advance to,
-      // but it still counts as completed (Emby Played flag, static watch
-      // party progress). Host-only, same as "next".
-      socket.on('itemEnded', this.safe(() => {
-        if (!party || userId !== party.hostUserId) {
-          return;
-        }
-        Logger.party(`item ended partyId=${party.id} item="${party.itemName}" (${party.queueIndex + 1}/${party.queue.length})`);
-        PartyService.completeCurrentItem(party);
-      }));
-
       // Host-only, video-only: picks (or clears) the party's *shared*
       // burn-in stream - see TranscodeService and Party.burnInSubtitleIndex's
       // own comment. Deliberately doesn't touch TranscodeService directly
@@ -425,11 +410,8 @@ class SocketGatewayClass {
   }
 
   private lobbySnapshot(): LobbyPartyDto[] {
-    // A solo catch-up session of a static watch party isn't something
+    return PartyService.listActive().map((party) => {
-    // anyone else should see or join - see Party.hiddenFromLobby.
-    return PartyService.listActive().filter((party) => !party.hiddenFromLobby).map((party) => {
       const host = party.members.get(party.hostUserId);
-      const staticParty = party.staticLink ? StaticPartyService.getById(party.staticLink.staticPartyId) : null;
       // Video only - see LobbyPartyDto's own comment for why music parties
       // get null here and fall back to createdUtc client-side instead.
       // The host is authoritative for position/pause the same way they are
@@ -447,9 +429,7 @@ class SocketGatewayClass {
         createdUtc: party.createdUtc, // client computes/ticks elapsed time itself from this
         positionTicks: isVideo && host ? host.positionTicks : null,
         isPaused: isVideo && host ? host.isPaused : null,
-        positionUpdatedUtc: isVideo && host ? host.lastUpdatedUtc : null,
+        positionUpdatedUtc: isVideo && host ? host.lastUpdatedUtc : null
-        staticPartyId: staticParty ? staticParty.id : null,
-        staticPartyName: staticParty ? staticParty.name : null
       };
     });
   }

server/src/services/CatalogService.ts

@@ -8,11 +8,10 @@ import type { EmbyItem, EmbySession, ItemDto, LibraryDto, MediaType, PlaybackMar
 
 // 'MusicVideo' is Emby's own item type for a musicvideos library's
 // contents (distinct from the generic 'Video', which is home videos).
-// 'Audio' is a music track. 'Series' isn't itself streamable, but
+// 'Audio' is a music track. Series/Season/MusicArtist/MusicAlbum aren't
-// launching one queues the whole series (see seriesQueueFrom and POST
+// directly playable - only show "start a party" for things Emby can
-// /api/parties). Season/MusicArtist/MusicAlbum get no tile button - their
+// actually stream. "Voir sur Emby" always works though.
-// own pages have their own launch actions. "Voir sur Emby" always works.
+const WATCH_PARTY_TYPES = new Set(['Movie', 'Episode', 'Video', 'MusicVideo', 'Audio']);
-const WATCH_PARTY_TYPES = new Set(['Movie', 'Episode', 'Video', 'MusicVideo', 'Audio', 'Series']);
 
 // Emby's /Views can return all sorts of things beyond actual media
 // libraries - boxset collections, live TV, photos, books, a mixed-content
@@ -69,36 +68,6 @@ export function imageUrlFor(item: EmbyItem): string {
   return `/api/catalog/image/${imageItemId}`;
 }
 
-/**
- * What a watch party queues from a series' full episode list (Emby's own
- * order, every season - see getAllSeriesEpisodesRaw): everything from
- * `fromEpisodeId` on, or - when launching the whole series - everything
- * from its first regular episode on. Specials (season 0) sort first in
- * Emby's list, so "the whole series" deliberately starts at S1E1, the
- * same queue clicking S1E1's own button builds. An unknown
- * `fromEpisodeId` yields an empty list (the caller falls back to the one
- * item). Pure.
- */
-export function seriesQueueFrom(episodes: EmbyItem[], fromEpisodeId?: string): EmbyItem[] {
-  if (fromEpisodeId) {
-    const index = episodes.findIndex((e) => e.Id === fromEpisodeId);
-    return index >= 0 ? episodes.slice(index) : [];
-  }
-  const firstRegular = episodes.findIndex((e) => e.ParentIndexNumber !== 0);
-  return firstRegular >= 0 ? episodes.slice(firstRegular) : episodes;
-}
-
-/**
- * Just one season's episodes, in Emby's order, out of a series' full
- * episode list - "launch this season". Matched by SeasonId, falling back
- * to the season number for an episode Emby returned without one. Pure.
- */
-export function seasonQueue(episodes: EmbyItem[], season: { Id: string; IndexNumber?: number }): EmbyItem[] {
-  return episodes.filter((e) => e.SeasonId
-    ? e.SeasonId === season.Id
-    : season.IndexNumber != null && e.ParentIndexNumber === season.IndexNumber);
-}
-
 export function splitPlaylistByMediaType(items: EmbyItem[]): { mediaType: MediaType; items: EmbyItem[] } {
   if (!items.length) return { mediaType: 'video', items: [] };
   const isMusic = items[0]!.Type === 'Audio';

server/src/services/PartyService.ts

@@ -8,7 +8,6 @@ import { PartyStreamService } from './PartyStreamService';
 import { PlaystateService } from './PlaystateService';
 import { CastTokenService } from './CastTokenService';
 import { EmbySessionService } from './EmbySessionService';
-import { StaticPartyService } from './StaticPartyService';
 import type { LeaveResult, MediaType, Party, PartyMember, PartyPublicState, QueueItem } from '../types';
 
 /**
@@ -210,7 +209,6 @@ class PartyServiceClass {
       MusicQueueService.destroy(party); // clears the auto-advance timer, if any - see its own comment
       TranscodeService.endSession(party.id); // no-op if this party never had a burn-in stream running
       PartyStreamService.endSession(party.id); // same - no-op if this party never negotiated a shared stream
-      if (party.staticLink) StaticPartyService.onPartyDestroyed(party.staticLink, party.id);
       Logger.party(`destroyed partyId=${party.id} (last member ${whoLeft} left)`);
     } else if (wasHost && newHostUserId != null) {
       const newHost = party.members.get(newHostUserId)!;
@@ -232,9 +230,7 @@ class PartyServiceClass {
     if (party.queueIndex >= party.queue.length - 1) {
       return false;
     }
-    // Whatever was just playing is "done" - before the party's own state
+    const outgoingItemId = party.itemId; // whatever was just playing - see the markPlayed loop below
-    // moves on. See completeCurrentItem's own comment.
-    this.completeCurrentItem(party);
     party.queueIndex += 1;
     const next = party.queue[party.queueIndex]!;
     party.itemId = next.itemId;
@@ -245,6 +241,18 @@ class PartyServiceClass {
       member.isPaused = false;
       member.lastUpdatedUtc = Date.now();
     }
+    // The party moving on from `outgoingItemId` is this app's own signal
+    // that it's "done" - see PlaystateService.markPlayed's own comment
+    // for why that's a heuristic, not a real "watched it all" check, and
+    // why every currently-connected member gets their own account
+    // updated, not just the host. Fire-and-forget, same as the periodic
+    // position sync in index.ts - a member's bad token or a transient
+    // Emby hiccup here must never block the party from actually moving
+    // on to the next item.
+    for (const member of party.members.values()) {
+      if (!member.connection || !member.embyToken) continue;
+      PlaystateService.markPlayed(member.embyToken, member.userId, outgoingItemId);
+    }
     // A new item's own MediaStreams indices have nothing to do with the
     // old one's - carrying a burn-in or text subtitle pick across would
     // show whatever track happens to share that index on the new item,
@@ -269,40 +277,6 @@ class PartyServiceClass {
     return true;
   }
 
-  /**
-   * Marks the party's current item as "done": the party moving on from it
-   * (advanceQueue) or the last queued item playing to its end (the host's
-   * "itemEnded" - see SocketGateway) is this app's own signal for that -
-   * see PlaystateService.markPlayed's own comment for why it's a
-   * heuristic, not a real "watched it all" check, and why every
-   * currently-connected member gets their own account updated, not just
-   * the host. Fire-and-forget, same as the periodic position sync in
-   * index.ts - a member's bad token or a transient Emby hiccup here must
-   * never block the party from actually moving on.
-   *
-   * For a session of a static watch party, also records the item as
-   * completed there (StaticPartyService.onItemCompleted) for every
-   * connected member. Idempotent per item (`lastCompletedItemId`), so an
-   * "itemEnded" and a later "next" on the same item never count twice.
-   */
-  completeCurrentItem(party: Party): void {
-    const itemId = party.itemId;
-    if (party.lastCompletedItemId === itemId) return;
-    party.lastCompletedItemId = itemId;
-    const connected = Array.from(party.members.values()).filter((m) => !!m.connection);
-    for (const member of connected) {
-      if (!member.embyToken) continue;
-      PlaystateService.markPlayed(member.embyToken, member.userId, itemId);
-    }
-    if (party.staticLink) {
-      StaticPartyService.onItemCompleted(
-        party.staticLink,
-        itemId,
-        connected.map((m) => ({ userId: m.userId, userName: m.userName }))
-      );
-    }
-  }
-
   /** All active parties - powers the "watch parties en cours" home section. */
   listActive(): Party[] {
     return Array.from(this.partiesById.values());
@@ -316,7 +290,6 @@ class PartyServiceClass {
         MusicQueueService.destroy(party); // same leak this class's own destroy path guards against
         TranscodeService.endSession(party.id); // same leak - see the "leave" destroy path above
         PartyStreamService.endSession(party.id);
-        if (party.staticLink) StaticPartyService.onPartyDestroyed(party.staticLink, party.id);
         // Same reasoning, for any member whose own "leave" (a clean
         // disconnect) never fired for whatever reason - a real gap would
         // otherwise leave a stale entry sitting in Emby's own dashboard

server/src/services/StaticPartyService.ts

@@ -1,319 +0,0 @@
-'use strict';
-
-import crypto from 'crypto';
-import { Logger } from '../Logger';
-import { StaticPartyStore } from './StaticPartyStore';
-import type {
-  PersistedStaticParty,
-  QueueItem,
-  StaticParty,
-  StaticPartyDetailDto,
-  StaticPartyLink,
-  StaticPartyMember,
-  StaticPartySummaryDto
-} from '../types';
-
-/** A connected participant, as reported by a live session. */
-export interface Participant {
-  userId: string;
-  userName: string;
-}
-
-/**
- * Which of `items` the viewer has missed, in the items' own order: every
- * item the group already completed, minus what the viewer watched in-app
- * (`watchedItemIds`) and minus what Emby itself already has as Played for
- * them (`embyPlayedIds` - watched outside this app, or before this party
- * existed). Pure - the one rule this whole feature is about, tested on
- * its own (see staticPartyService.test.ts).
- */
-export function computeMissedIds(
-  items: QueueItem[],
-  completedItemIds: string[],
-  watchedItemIds: string[],
-  embyPlayedIds: ReadonlySet<string>
-): string[] {
-  const completed = new Set(completedItemIds);
-  const watched = new Set(watchedItemIds);
-  return items
-    .map((i) => i.itemId)
-    .filter((id) => completed.has(id) && !watched.has(id) && !embyPlayedIds.has(id));
-}
-
-/**
- * Merges a freshly fetched item list into a static party's existing one:
- * keeps the existing order and every existing item (even one since
- * removed from the source - the group's history shouldn't lose it),
- * refreshes names/images, and appends anything new (a new episode, a
- * playlist addition) at the end in the source's own order. Returns the
- * merged list and how many items were added. Pure.
- */
-export function mergeItemLists(existing: QueueItem[], fresh: QueueItem[]): { items: QueueItem[]; added: number } {
-  const freshById = new Map(fresh.map((i) => [i.itemId, i]));
-  const known = new Set(existing.map((i) => i.itemId));
-  const items = existing.map((i) => freshById.get(i.itemId) ?? i);
-  const additions = fresh.filter((i) => !known.has(i.itemId));
-  return { items: items.concat(additions), added: additions.length };
-}
-
-/**
- * Static (persistent) watch parties - a whole series or video playlist a
- * group watches together over several sessions. Remembers the group's own
- * progress (which items it completed, where it stopped) and each member's
- * own (which items they watched), so someone coming back or joining late
- * sees exactly what they missed. See spec/static-watch-party.md.
- *
- * A static party never plays anything itself: each session is an
- * ordinary live Party (PartyService), created by index.ts and linked back
- * here through `party.staticLink` - so the player, sync, shared stream,
- * lobby and host handoff are all reused as-is. This service never imports
- * PartyService (PartyService calls into this one), keeping the dependency
- * one-way.
- *
- * Persisted through StaticPartyStore after every change - one file per
- * party, so only the party that changed is ever rewritten.
- */
-class StaticPartyServiceClass {
-  /** Every static party, by id. */
-  private partiesById = new Map<string, StaticParty>();
-
-  /** Loads every persisted party - once, at startup. */
-  public init(): void {
-    this.partiesById.clear();
-    for (const persisted of StaticPartyStore.load()) {
-      this.partiesById.set(persisted.id, { ...persisted, livePartyId: null });
-    }
-  }
-
-  /** Every static party, most recently active first. */
-  public list(): StaticParty[] {
-    return Array.from(this.partiesById.values()).sort((a, b) => this.lastActivity(b) - this.lastActivity(a));
-  }
-
-  /** One static party, or null. */
-  public getById(id: string): StaticParty | null {
-    return this.partiesById.get(id) || null;
-  }
-
-  /** Creates a static party over `items` - the creator is its first member. */
-  public create(
-    creator: Participant,
-    source: StaticParty['source'],
-    name: string,
-    imageUrl: string,
-    items: QueueItem[]
-  ): StaticParty {
-    const now = Date.now();
-    const sp: StaticParty = {
-      id: crypto.randomUUID(),
-      name,
-      source,
-      imageUrl,
-      createdByUserId: creator.userId,
-      createdUtc: now,
-      items,
-      group: { nextIndex: 0, resumePositionTicks: 0, completedItemIds: [], lastSessionUtc: null },
-      members: {},
-      livePartyId: null
-    };
-    sp.members[creator.userId] = this.newMember(creator);
-    this.partiesById.set(sp.id, sp);
-    Logger.staticParty(`created id=${sp.id} name="${name}" source=${source.type}:${source.sourceId} items=${items.length} by=${Logger.who(creator.userId, creator.userName)}`);
-    this.persist(sp);
-    return sp;
-  }
-
-  /** Adds `who` as a member - idempotent (refreshes their name only). */
-  public join(sp: StaticParty, who: Participant): StaticPartyMember {
-    const existing = sp.members[who.userId];
-    if (existing) {
-      existing.userName = who.userName;
-      existing.lastSeenUtc = Date.now();
-      this.persist(sp);
-      return existing;
-    }
-    const member = this.newMember(who);
-    sp.members[who.userId] = member;
-    Logger.staticParty(`joined id=${sp.id} user=${Logger.who(who.userId, who.userName)} members=${Object.keys(sp.members).length}`);
-    this.persist(sp);
-    return member;
-  }
-
-  /** Removes a member - and their progress. The party itself stays, even
-   *  empty: only its creator deletes it (see delete()). */
-  public leave(sp: StaticParty, userId: string): void {
-    const member = sp.members[userId];
-    if (!member) return;
-    delete sp.members[userId];
-    Logger.staticParty(`left id=${sp.id} user=${Logger.who(userId, member.userName)} members=${Object.keys(sp.members).length}`);
-    this.persist(sp);
-  }
-
-  /** Deletes the party for good - creator only. Returns false (and does
-   *  nothing) for anyone else. */
-  public delete(sp: StaticParty, userId: string): boolean {
-    if (sp.createdByUserId !== userId) {
-      Logger.staticParty(`delete refused id=${sp.id} user=${userId} (not the creator)`);
-      return false;
-    }
-    this.partiesById.delete(sp.id);
-    Logger.staticParty(`deleted id=${sp.id} name="${sp.name}"`);
-    StaticPartyStore.remove(sp.id);
-    return true;
-  }
-
-  /** Merges a fresh fetch of the source into `sp.items` (see
-   *  mergeItemLists) - new episodes/playlist entries appear at the end. */
-  public refreshItems(sp: StaticParty, fresh: QueueItem[]): void {
-    if (!fresh.length) return;
-    const { items, added } = mergeItemLists(sp.items, fresh);
-    const changed = added > 0 || items.some((item, i) => item !== sp.items[i]);
-    sp.items = items;
-    if (added) Logger.staticParty(`refreshed id=${sp.id} +${added} new item(s), total=${items.length}`);
-    if (changed) this.persist(sp);
-  }
-
-  /** What the group's next session plays: everything from the group's
-   *  next item on. Empty once the group has seen everything. */
-  public groupQueue(sp: StaticParty): QueueItem[] {
-    return sp.items.slice(sp.group.nextIndex);
-  }
-
-  /** Records which live party is the group's current session (or none). */
-  public setLiveParty(sp: StaticParty, partyId: string | null): void {
-    sp.livePartyId = partyId;
-    if (partyId) {
-      sp.group.lastSessionUtc = Date.now();
-      Logger.staticParty(`session started id=${sp.id} partyId=${partyId} at item ${sp.group.nextIndex + 1}/${sp.items.length}`);
-      this.persist(sp);
-    }
-  }
-
-  /**
-   * A linked live session finished `itemId` (played to its end, or the
-   * host moved past it - the same heuristic as PlaystateService.markPlayed).
-   * Every connected participant gets it as watched (and becomes a member
-   * if they joined the live session without joining the static party
-   * first). In `group` mode the group itself also moves past it; in
-   * `catchUp` mode only those participants' own progress changes.
-   */
-  public onItemCompleted(link: StaticPartyLink, itemId: string, connected: Participant[]): void {
-    const sp = this.partiesById.get(link.staticPartyId);
-    if (!sp) return; // deleted while a session was still running
-    for (const who of connected) {
-      const member = sp.members[who.userId] ?? (sp.members[who.userId] = this.newMember(who));
-      member.lastSeenUtc = Date.now();
-      if (!member.watchedItemIds.includes(itemId)) member.watchedItemIds.push(itemId);
-    }
-    if (link.mode === 'group') {
-      if (!sp.group.completedItemIds.includes(itemId)) sp.group.completedItemIds.push(itemId);
-      const index = sp.items.findIndex((i) => i.itemId === itemId);
-      if (index >= 0 && index + 1 > sp.group.nextIndex) sp.group.nextIndex = index + 1;
-      sp.group.resumePositionTicks = 0;
-    }
-    Logger.staticParty(`item completed id=${sp.id} mode=${link.mode} item=${itemId} by=[${connected.map((c) => c.userName).join(', ')}] group=${sp.group.completedItemIds.length}/${sp.items.length}`);
-    this.persist(sp);
-  }
-
-  /** The group session's current position - saved so the next session
-   *  resumes there. Ignored for anything but the group's next item. */
-  public recordPosition(link: StaticPartyLink, itemId: string, positionTicks: number): void {
-    if (link.mode !== 'group') return;
-    const sp = this.partiesById.get(link.staticPartyId);
-    if (!sp || sp.items[sp.group.nextIndex]?.itemId !== itemId) return;
-    if (sp.group.resumePositionTicks === positionTicks) return;
-    sp.group.resumePositionTicks = positionTicks;
-    this.persist(sp);
-  }
-
-  /** A linked live party ended - forget it as the group's live session. */
-  public onPartyDestroyed(link: StaticPartyLink, partyId: string): void {
-    const sp = this.partiesById.get(link.staticPartyId);
-    if (!sp || sp.livePartyId !== partyId) return;
-    sp.livePartyId = null;
-    Logger.staticParty(`session ended id=${sp.id} partyId=${partyId} resumeAt=item ${sp.group.nextIndex + 1} ${Math.round(sp.group.resumePositionTicks / 10000000)}s`);
-    this.persist(sp);
-  }
-
-  /** "Marquer comme vu" - `who` becomes a member if they weren't yet. */
-  public markWatched(sp: StaticParty, who: Participant, itemId: string): boolean {
-    if (!sp.items.some((i) => i.itemId === itemId)) return false;
-    const member = sp.members[who.userId] ?? (sp.members[who.userId] = this.newMember(who));
-    if (!member.watchedItemIds.includes(itemId)) member.watchedItemIds.push(itemId);
-    member.lastSeenUtc = Date.now();
-    Logger.staticParty(`marked watched id=${sp.id} user=${Logger.who(who.userId, who.userName)} item=${itemId}`);
-    this.persist(sp);
-    return true;
-  }
-
-  /** `viewerUserId`'s missed items - see computeMissedIds. */
-  public missedIds(sp: StaticParty, viewerUserId: string, embyPlayedIds: ReadonlySet<string>): string[] {
-    const watched = sp.members[viewerUserId]?.watchedItemIds ?? [];
-    return computeMissedIds(sp.items, sp.group.completedItemIds, watched, embyPlayedIds);
-  }
-
-  /** The list-view shape of `sp` for `viewerUserId`. `livePartyId` is
-   *  passed in already checked against PartyService (still alive). */
-  public toSummary(sp: StaticParty, viewerUserId: string, embyPlayedIds: ReadonlySet<string>, livePartyId: string | null): StaticPartySummaryDto {
-    return {
-      id: sp.id,
-      name: sp.name,
-      sourceType: sp.source.type,
-      imageUrl: sp.imageUrl,
-      itemCount: sp.items.length,
-      groupWatchedCount: sp.group.completedItemIds.length,
-      nextItemName: sp.items[sp.group.nextIndex]?.itemName ?? null,
-      memberCount: Object.keys(sp.members).length,
-      youAreMember: !!sp.members[viewerUserId],
-      youAreCreator: sp.createdByUserId === viewerUserId,
-      missedCount: this.missedIds(sp, viewerUserId, embyPlayedIds).length,
-      livePartyId
-    };
-  }
-
-  /** The detail-view shape of `sp` for `viewerUserId`. */
-  public toDetail(sp: StaticParty, viewerUserId: string, embyPlayedIds: ReadonlySet<string>, livePartyId: string | null): StaticPartyDetailDto {
-    const completed = new Set(sp.group.completedItemIds);
-    const viewerWatched = new Set(sp.members[viewerUserId]?.watchedItemIds ?? []);
-    return {
-      ...this.toSummary(sp, viewerUserId, embyPlayedIds, livePartyId),
-      items: sp.items.map((item, index) => ({
-        ...item,
-        groupState: completed.has(item.itemId) ? 'watched' : index === sp.group.nextIndex ? 'next' : 'upcoming',
-        viewerWatched: viewerWatched.has(item.itemId) || embyPlayedIds.has(item.itemId)
-      })),
-      missedItemIds: this.missedIds(sp, viewerUserId, embyPlayedIds),
-      members: Object.values(sp.members).map((m) => ({
-        userId: m.userId,
-        userName: m.userName,
-        watchedCount: m.watchedItemIds.length,
-        isCreator: m.userId === sp.createdByUserId
-      }))
-    };
-  }
-
-  /** Writes `sp`'s own file (debounced - see StaticPartyStore). Only the
-   *  party that changed is ever rewritten. */
-  private persist(sp: StaticParty): void {
-    StaticPartyStore.save(sp.id, () => this.snapshotOf(sp));
-  }
-
-  /** `sp` minus runtime-only state. */
-  private snapshotOf(sp: StaticParty): PersistedStaticParty {
-    const { livePartyId: _live, ...persisted } = sp;
-    return persisted;
-  }
-
-  /** When `sp` last saw anything happen - for list ordering. */
-  private lastActivity(sp: StaticParty): number {
-    return Math.max(sp.createdUtc, sp.group.lastSessionUtc ?? 0);
-  }
-
-  /** A fresh member record for `who`. */
-  private newMember(who: Participant): StaticPartyMember {
-    const now = Date.now();
-    return { userId: who.userId, userName: who.userName, joinedUtc: now, watchedItemIds: [], lastSeenUtc: now };
-  }
-}
-
-export const StaticPartyService = new StaticPartyServiceClass();

server/src/services/StaticPartyStore.ts

@@ -1,272 +0,0 @@
-'use strict';
-
-import fs from 'fs';
-import path from 'path';
-import { Logger } from '../Logger';
-import type { PersistedStaticParty } from '../types';
-
-/** One party's own file - versioned so a future format change can migrate
- *  instead of silently misreading an older file. */
-interface StaticPartyFile {
-  version: 1;
-  party: PersistedStaticParty;
-}
-
-/** The first release's single-file format - only read once, to migrate. */
-interface LegacyStaticPartiesFile {
-  version: 1;
-  parties: PersistedStaticParty[];
-}
-
-/** How long a save waits for more changes to the same party before
- *  writing - progress updates arrive in bursts (a whole party's members
- *  at once, the 20s position sweep). */
-const SAVE_DEBOUNCE_MS = 2000;
-
-/** Party ids become file names - anything else is refused outright, so a
- *  crafted id can never reach outside the directory. */
-const SAFE_ID = /^[A-Za-z0-9-]+$/;
-
-/**
- * The static watch parties' persistence: **one JSON file per party**,
- * `${DATA_DIR}/static-parties/<id>.json` - the first and only thing this
- * app keeps on disk (everything else is deliberately in-memory - see
- * docs/architecture.md's "Party lifecycle").
- *
- * One file per party (rather than a single file for all of them) limits
- * what any one problem can damage: a write only ever touches the party
- * that changed, and a corrupt file costs that one party, never the rest.
- * Each write is also atomic (a `.tmp` sibling, then a rename over the
- * real file), so a crash mid-write leaves the previous version intact.
- *
- * Writes are debounced per party (SAVE_DEBOUNCE_MS). A corrupt file is
- * logged and moved aside (`.corrupt`) rather than overwritten or
- * silently dropped - the server must never refuse to start over one, and
- * nothing is lost for good. The first release's single
- * `static-parties.json` is migrated once, on the first load that finds it.
- *
- * JSON files rather than a database: the data is tiny, the runtime image
- * is Node 20 (no built-in `node:sqlite`), and a native SQLite binding would
- * be the image's first compiled dependency - not worth it at this size.
- */
-class StaticPartyStoreClass {
-  /** `${DATA_DIR}/static-parties` - see configure(). */
-  private dir: string | null = null;
-  /** The first release's single file, migrated on load if still present. */
-  private legacyFile: string | null = null;
-  /** Pending debounced saves, by party id. */
-  private timers = new Map<string, NodeJS.Timeout>();
-  /** What each pending save will write - always the latest snapshot. */
-  private pending = new Map<string, () => PersistedStaticParty>();
-
-  /** Points the store at `dataDir`. Must be called before anything else -
-   *  index.ts does it at startup, tests with a temp directory. */
-  public configure(dataDir: string): void {
-    this.dir = path.resolve(dataDir, 'static-parties');
-    this.legacyFile = path.resolve(dataDir, 'static-parties.json');
-  }
-
-  /** Reads every persisted party - synchronous, startup-only. */
-  public load(): PersistedStaticParty[] {
-    const dir = this.requireDir();
-    try {
-      fs.mkdirSync(dir, { recursive: true });
-    } catch (err) {
-      Logger.staticParty(`could not create ${dir} - starting empty: ${(err as Error).message}`);
-      return [];
-    }
-    this.migrateLegacyFile();
-
-    let names: string[];
-    try {
-      names = fs.readdirSync(dir);
-    } catch (err) {
-      Logger.staticParty(`could not list ${dir} - starting empty: ${(err as Error).message}`);
-      return [];
-    }
-
-    const parties: PersistedStaticParty[] = [];
-    for (const name of names) {
-      const file = path.join(dir, name);
-      if (name.endsWith('.tmp')) {
-        // A write interrupted before its rename - the real file next to it
-        // (if any) is still the last complete version.
-        this.tryUnlink(file);
-        continue;
-      }
-      if (!name.endsWith('.json')) continue; // .corrupt files and anything else
-      const party = this.readPartyFile(file);
-      if (party) parties.push(party);
-    }
-    Logger.staticParty(`loaded ${parties.length} static party(ies) from ${dir}`);
-    return parties;
-  }
-
-  /** Schedules a debounced write of `id`'s own file, from whatever
-   *  `snapshot` returns at write time (so a burst of changes only ever
-   *  writes the final state). */
-  public save(id: string, snapshot: () => PersistedStaticParty): void {
-    if (!SAFE_ID.test(id)) {
-      Logger.staticParty(`save refused: unsafe id "${id}"`);
-      return;
-    }
-    this.pending.set(id, snapshot);
-    if (this.timers.has(id)) return;
-    const timer = setTimeout(() => {
-      this.timers.delete(id);
-      this.writeOne(id).catch((err: unknown) => {
-        Logger.staticParty(`save failed id=${id}: ${(err as Error).message}`);
-      });
-    }, SAVE_DEBOUNCE_MS);
-    timer.unref(); // a pending save must never keep a test process (or a shutdown) alive
-    this.timers.set(id, timer);
-  }
-
-  /** Deletes `id`'s file - and cancels any save still pending for it, so
-   *  a debounced write can't recreate a party that was just deleted. */
-  public remove(id: string): void {
-    const timer = this.timers.get(id);
-    if (timer) clearTimeout(timer);
-    this.timers.delete(id);
-    this.pending.delete(id);
-    if (!SAFE_ID.test(id)) return;
-    const file = this.fileFor(id);
-    try {
-      fs.unlinkSync(file);
-      Logger.staticParty(`removed ${file}`);
-    } catch (err) {
-      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
-        Logger.staticParty(`could not remove ${file}: ${(err as Error).message}`);
-      }
-    }
-  }
-
-  /** Writes every pending save immediately and synchronously - for a
-   *  graceful shutdown (SIGTERM/SIGINT), where an async write could be cut
-   *  short by the process exiting. */
-  public flushSync(): void {
-    for (const timer of this.timers.values()) clearTimeout(timer);
-    this.timers.clear();
-    const pending = Array.from(this.pending.entries());
-    this.pending.clear();
-    for (const [id, snapshot] of pending) {
-      const file = this.fileFor(id);
-      try {
-        fs.mkdirSync(path.dirname(file), { recursive: true });
-        fs.writeFileSync(`${file}.tmp`, this.serialize(snapshot()), 'utf8');
-        fs.renameSync(`${file}.tmp`, file);
-      } catch (err) {
-        Logger.staticParty(`flush failed id=${id}: ${(err as Error).message}`);
-      }
-    }
-    if (pending.length) Logger.staticParty(`flushed ${pending.length} static party(ies)`);
-  }
-
-  /** Writes every pending save now (async) - lets tests wait for disk. */
-  public async writeNow(): Promise<void> {
-    for (const timer of this.timers.values()) clearTimeout(timer);
-    this.timers.clear();
-    const ids = Array.from(this.pending.keys());
-    try {
-      await Promise.all(ids.map((id) => this.writeOne(id)));
-    } catch (err) {
-      Logger.staticParty(`writeNow failed: ${(err as Error).message}`);
-      throw err;
-    }
-  }
-
-  /** Writes `id`'s pending snapshot - atomically, via a `.tmp` rename. */
-  private async writeOne(id: string): Promise<void> {
-    const snapshot = this.pending.get(id);
-    if (!snapshot) return;
-    this.pending.delete(id);
-    const file = this.fileFor(id);
-    try {
-      await fs.promises.mkdir(path.dirname(file), { recursive: true });
-      await fs.promises.writeFile(`${file}.tmp`, this.serialize(snapshot()), 'utf8');
-      await fs.promises.rename(`${file}.tmp`, file);
-    } catch (err) {
-      Logger.staticParty(`write to ${file} failed: ${(err as Error).message}`);
-      throw err;
-    }
-  }
-
-  /** One party file's content, or null (moved aside) if it's unreadable. */
-  private readPartyFile(file: string): PersistedStaticParty | null {
-    try {
-      const parsed = JSON.parse(fs.readFileSync(file, 'utf8')) as Partial<StaticPartyFile>;
-      const party = parsed?.party;
-      if (!party || typeof party.id !== 'string' || !Array.isArray(party.items)) {
-        throw new Error('missing or malformed "party"');
-      }
-      if (path.basename(file) !== `${party.id}.json`) throw new Error(`file name does not match id ${party.id}`);
-      return party;
-    } catch (err) {
-      Logger.staticParty(`corrupt file ${file} - moved aside to .corrupt, skipped: ${(err as Error).message}`);
-      try {
-        fs.renameSync(file, `${file}.corrupt`);
-      } catch (renameErr) {
-        Logger.staticParty(`could not move corrupt file aside: ${(renameErr as Error).message}`);
-      }
-      return null;
-    }
-  }
-
-  /**
-   * The first release kept every party in one `static-parties.json` -
-   * split it into one file per party, then rename it to `.migrated` (kept,
-   * not deleted, in case anything went wrong). A party that already has
-   * its own file is left alone: that file is newer.
-   */
-  private migrateLegacyFile(): void {
-    const legacy = this.legacyFile!;
-    if (!fs.existsSync(legacy)) return;
-    try {
-      const parsed = JSON.parse(fs.readFileSync(legacy, 'utf8')) as Partial<LegacyStaticPartiesFile>;
-      const parties = Array.isArray(parsed?.parties) ? parsed.parties : [];
-      let migrated = 0;
-      for (const party of parties) {
-        if (!party || typeof party.id !== 'string' || !SAFE_ID.test(party.id)) continue;
-        const file = this.fileFor(party.id);
-        if (fs.existsSync(file)) continue;
-        fs.writeFileSync(`${file}.tmp`, this.serialize(party), 'utf8');
-        fs.renameSync(`${file}.tmp`, file);
-        migrated++;
-      }
-      fs.renameSync(legacy, `${legacy}.migrated`);
-      Logger.staticParty(`migrated ${migrated} static party(ies) from ${legacy} to one file each (original kept as .migrated)`);
-    } catch (err) {
-      Logger.staticParty(`could not migrate ${legacy} - left in place: ${(err as Error).message}`);
-    }
-  }
-
-  /** `id`'s own file path. */
-  private fileFor(id: string): string {
-    return path.join(this.requireDir(), `${id}.json`);
-  }
-
-  /** A party file's JSON text. */
-  private serialize(party: PersistedStaticParty): string {
-    const data: StaticPartyFile = { version: 1, party };
-    return JSON.stringify(data, null, 2);
-  }
-
-  /** Best-effort delete - logs anything but "already gone". */
-  private tryUnlink(file: string): void {
-    try {
-      fs.unlinkSync(file);
-    } catch (err) {
-      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
-        Logger.staticParty(`could not remove ${file}: ${(err as Error).message}`);
-      }
-    }
-  }
-
-  /** The configured directory - throws if configure() was never called. */
-  private requireDir(): string {
-    if (!this.dir) throw new Error('StaticPartyStore.configure() was never called');
-    return this.dir;
-  }
-}
-
-export const StaticPartyStore = new StaticPartyStoreClass();

server/src/types.ts

@@ -29,11 +29,6 @@ export interface ClientToServerEvents {
   join: (msg: { partyId: string; deviceId: string; force?: boolean }) => void;
   playstate: (msg: { isPaused: boolean; positionTicks: number }) => void;
   next: () => void;
-  /** Host-only (checked server-side exactly like "next") - the last
-   *  queued item played to its end, so there's no "next" to send. Lets
-   *  the server count that final item as completed (PartyService
-   *  .completeCurrentItem) without advancing anything. */
-  itemEnded: () => void;
   voteSkip: () => void;
   musicPlaystate: (msg: { isPaused: boolean }) => void;
   /** No host check, same as "musicPlaystate" - see MusicQueueService's own
@@ -173,8 +168,6 @@ export interface EmbyItem {
   Type?: string;
   SeriesId?: string;
   SeriesName?: string;
-  /** An episode's own season - see CatalogService.seasonQueue. */
-  SeasonId?: string;
   ParentIndexNumber?: number;
   IndexNumber?: number;
   RunTimeTicks?: number;
@@ -187,11 +180,6 @@ export interface EmbyItem {
    *  one sampled 500'd), only its album does - this is how an image URL
    *  falls back to the album's art instead. */
   AlbumId?: string;
-  /** The requesting user's own per-item state - Emby embeds it on every
-   *  item fetched with a userId, unasked (see PlaystateService's own
-   *  comment). Only `Played` is read, by the static watch party's
-   *  "missed items" computation (StaticPartyService). */
-  UserData?: { Played?: boolean };
 }
 
 /** This app's own DTO shape - what toItemDto() in CatalogService produces,
@@ -371,25 +359,6 @@ export interface Party {
    *  MusicBar.ts never had this picker in the first place. */
   streamAudioIndex: string | null;
   streamQuality: string | null;
-  /** Set only for a live session launched from a static watch party (see
-   *  StaticPartyService) - absent for every ordinary party. */
-  staticLink?: StaticPartyLink;
-  /** Kept out of the home page's live lobby list (SocketGateway
-   *  .lobbySnapshot) - a solo catch-up session of a static watch party. */
-  hiddenFromLobby?: boolean;
-  /** The last item this party already reported as completed (see
-   *  PartyService.completeCurrentItem) - guards against an "itemEnded"
-   *  followed by a "next" on the same item counting it twice. */
-  lastCompletedItemId?: string | null;
-}
-
-/** How a live party relates to the static watch party it was launched
- *  from - `group` is the group's own session (advances the group's
- *  progress), `catchUp` is someone catching up on items they missed
- *  (only marks those items watched for whoever was connected). */
-export interface StaticPartyLink {
-  staticPartyId: string;
-  mode: 'group' | 'catchUp';
 }
 
 export interface PublicMember {
@@ -446,92 +415,6 @@ export interface LobbyPartyDto {
   positionTicks: number | null;
   isPaused: boolean | null;
   positionUpdatedUtc: number | null;
-  /** The static watch party this live session belongs to, if any - shown
-   *  as a badge on the home page's lobby card. */
-  staticPartyId: string | null;
-  staticPartyName: string | null;
-}
-
-// --- Static (persistent) watch party ------------------------------------------
-
-/** A lounge party's source: a whole series, one season of it, or a
- *  video playlist. */
-export type StaticPartySourceType = 'series' | 'season' | 'playlist';
-
-/** One member of a static watch party - persisted, independent of any
- *  live connection (unlike PartyMember). */
-export interface StaticPartyMember {
-  userId: string;
-  userName: string;
-  joinedUtc: number;
-  /** Items this member watched in-app: with the group, in a catch-up
-   *  session, or marked watched by hand. Emby's own Played flag is
-   *  combined with this at read time, never copied into it. */
-  watchedItemIds: string[];
-  lastSeenUtc: number;
-}
-
-/** The group's own progress through a static watch party's items. */
-export interface StaticPartyGroupProgress {
-  /** Index into `items` of the next item the group will watch. */
-  nextIndex: number;
-  /** Where the group stopped inside items[nextIndex] - applied as the
-   *  host's starting position on the next session. */
-  resumePositionTicks: number;
-  completedItemIds: string[];
-  lastSessionUtc: number | null;
-}
-
-/** A persistent watch party over a whole series or video playlist - see
- *  StaticPartyService and spec/static-watch-party.md. */
-export interface StaticParty {
-  id: string;
-  name: string;
-  /** What the items come from. A `season` also records its series
-   *  (`seriesId`) and number (`seasonNumber`) - episodes are fetched per
-   *  series, then filtered (see CatalogService.seasonQueue). */
-  source: { type: StaticPartySourceType; sourceId: string; seriesId?: string; seasonNumber?: number };
-  imageUrl: string;
-  createdByUserId: string;
-  createdUtc: number;
-  items: QueueItem[];
-  group: StaticPartyGroupProgress;
-  members: Record<string, StaticPartyMember>;
-  /** Runtime only (never persisted) - the live group session, if any. */
-  livePartyId: string | null;
-}
-
-/** The persisted shape of a StaticParty - everything but runtime state. */
-export type PersistedStaticParty = Omit<StaticParty, 'livePartyId'>;
-
-/** One item of a static watch party, as the client sees it. */
-export interface StaticPartyItemDto extends QueueItem {
-  groupState: 'watched' | 'next' | 'upcoming';
-  /** Whether the viewer has watched it (in-app or Emby's Played flag). */
-  viewerWatched: boolean;
-}
-
-/** GET /api/static-parties list entry. */
-export interface StaticPartySummaryDto {
-  id: string;
-  name: string;
-  sourceType: StaticPartySourceType;
-  imageUrl: string;
-  itemCount: number;
-  groupWatchedCount: number;
-  nextItemName: string | null;
-  memberCount: number;
-  youAreMember: boolean;
-  youAreCreator: boolean;
-  missedCount: number;
-  livePartyId: string | null;
-}
-
-/** GET /api/static-parties/:id - the summary plus every item and member. */
-export interface StaticPartyDetailDto extends StaticPartySummaryDto {
-  items: StaticPartyItemDto[];
-  missedItemIds: string[];
-  members: Array<{ userId: string; userName: string; watchedCount: number; isCreator: boolean }>;
 }
 
 export interface LeaveResult {

server/test/catalogService.test.ts

@@ -4,7 +4,7 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import type { Request, Response } from 'express';
-import { CatalogService, imageUrlFor, seasonQueue, seriesQueueFrom, splitPlaylistByMediaType } from '../src/services/CatalogService';
+import { CatalogService, imageUrlFor, splitPlaylistByMediaType } from '../src/services/CatalogService';
 import { EmbyClient } from '../src/emby/EmbyClient';
 import type { EmbyItem, EmbySession } from '../src/types';
 
@@ -314,34 +314,3 @@ describe('imageUrlFor', () => {
     assert.equal(imageUrlFor({ Id: 't1', Name: 'Track', Type: 'Audio' }), '/api/catalog/image/t1');
   });
 });
-
-describe('seriesQueueFrom / seasonQueue', () => {
-  const ep = (id: string, season: number, seasonId?: string): EmbyItem => ({ Id: id, Name: id, Type: 'Episode', ParentIndexNumber: season, SeasonId: seasonId });
-  // Emby's own order: specials (season 0) first, then every season in turn.
-  const all = [ep('sp1', 0, 'se0'), ep('s1e1', 1, 'se1'), ep('s1e2', 1, 'se1'), ep('s2e1', 2, 'se2'), ep('s2e2', 2, 'se2')];
-
-  it('the whole series starts at S1E1 - specials sort first and are skipped', () => {
-    assert.deepEqual(seriesQueueFrom(all).map((e) => e.Id), ['s1e1', 's1e2', 's2e1', 's2e2']);
-  });
-
-  it('a series with only specials still queues them', () => {
-    assert.deepEqual(seriesQueueFrom([ep('sp1', 0), ep('sp2', 0)]).map((e) => e.Id), ['sp1', 'sp2']);
-  });
-
-  it('from an episode, queues it and everything after it, across seasons', () => {
-    assert.deepEqual(seriesQueueFrom(all, 's1e2').map((e) => e.Id), ['s1e2', 's2e1', 's2e2']);
-  });
-
-  it('an unknown starting episode yields nothing (the caller falls back to that one item)', () => {
-    assert.deepEqual(seriesQueueFrom(all, 'nope'), []);
-  });
-
-  it('a season queues only its own episodes', () => {
-    assert.deepEqual(seasonQueue(all, { Id: 'se1', IndexNumber: 1 }).map((e) => e.Id), ['s1e1', 's1e2']);
-  });
-
-  it('a season falls back to the season number for episodes without a SeasonId', () => {
-    const noIds = [ep('a', 1), ep('b', 2), ep('c', 2)];
-    assert.deepEqual(seasonQueue(noIds, { Id: 'se2', IndexNumber: 2 }).map((e) => e.Id), ['b', 'c']);
-  });
-});

server/test/staticPartyService.test.ts

@@ -1,299 +0,0 @@
-import { describe, it, before, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { StaticPartyService, computeMissedIds, mergeItemLists } from '../src/services/StaticPartyService';
-import { StaticPartyStore } from '../src/services/StaticPartyStore';
-import { PartyService } from '../src/services/PartyService';
-import { PlaystateService } from '../src/services/PlaystateService';
-import type { AppSocket, QueueItem } from '../src/types';
-
-const item = (id: string): QueueItem => ({ itemId: id, itemName: `Episode ${id}`, itemImageUrl: `/img/${id}` });
-const ITEMS = ['e1', 'e2', 'e3', 'e4'].map(item);
-const alice = { userId: 'u-alice', userName: 'Alice' };
-const bob = { userId: 'u-bob', userName: 'Bob' };
-const NONE: ReadonlySet<string> = new Set();
-
-let dataDir: string;
-
-before(() => {
-  dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'wp-static-'));
-  StaticPartyStore.configure(dataDir);
-});
-
-const partiesDir = () => path.join(dataDir, 'static-parties');
-
-beforeEach(() => {
-  StaticPartyStore.flushSync(); // no debounced save from a previous test may land mid-test
-  fs.rmSync(partiesDir(), { recursive: true, force: true });
-  for (const name of fs.readdirSync(dataDir)) fs.rmSync(path.join(dataDir, name), { recursive: true, force: true });
-  StaticPartyService.init();
-});
-
-describe('computeMissedIds', () => {
-  it('is every group-completed item, in the items\' own order', () => {
-    assert.deepEqual(computeMissedIds(ITEMS, ['e2', 'e1'], [], NONE), ['e1', 'e2']);
-  });
-
-  it('drops what the viewer watched in-app and what Emby already has as Played', () => {
-    assert.deepEqual(computeMissedIds(ITEMS, ['e1', 'e2', 'e3'], ['e1'], new Set(['e3'])), ['e2']);
-  });
-
-  it('never lists an item the group has not completed yet, even if the viewer watched ahead', () => {
-    assert.deepEqual(computeMissedIds(ITEMS, ['e1'], ['e4'], NONE), ['e1']);
-  });
-});
-
-describe('mergeItemLists', () => {
-  it('keeps the existing order, appends new items and keeps ones gone from the source', () => {
-    const { items, added } = mergeItemLists([item('e1'), item('e2')], [item('e2'), item('e3')]);
-    assert.deepEqual(items.map((i) => i.itemId), ['e1', 'e2', 'e3']);
-    assert.equal(added, 1);
-  });
-
-  it('refreshes a known item\'s name from the fresh fetch', () => {
-    const { items } = mergeItemLists([item('e1')], [{ ...item('e1'), itemName: 'Renamed' }]);
-    assert.equal(items[0]!.itemName, 'Renamed');
-  });
-});
-
-describe('StaticPartyService', () => {
-  it('create() makes the creator the first member, with nothing watched yet', () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS);
-    assert.deepEqual(Object.keys(sp.members), ['u-alice']);
-    assert.equal(sp.group.nextIndex, 0);
-    assert.deepEqual(StaticPartyService.groupQueue(sp).map((i) => i.itemId), ['e1', 'e2', 'e3', 'e4']);
-  });
-
-  it('a group completion advances the group and credits only connected participants', () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS);
-    StaticPartyService.join(sp, bob);
-    const link = { staticPartyId: sp.id, mode: 'group' as const };
-
-    StaticPartyService.onItemCompleted(link, 'e1', [alice, bob]);
-    StaticPartyService.onItemCompleted(link, 'e2', [alice]); // Bob missed this one
-
-    assert.equal(sp.group.nextIndex, 2);
-    assert.deepEqual(sp.group.completedItemIds, ['e1', 'e2']);
-    assert.deepEqual(StaticPartyService.missedIds(sp, bob.userId, NONE), ['e2']);
-    assert.deepEqual(StaticPartyService.missedIds(sp, alice.userId, NONE), []);
-    assert.deepEqual(StaticPartyService.groupQueue(sp).map((i) => i.itemId), ['e3', 'e4']);
-  });
-
-  it('a late joiner sees everything the group completed before them as missed', () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS);
-    StaticPartyService.onItemCompleted({ staticPartyId: sp.id, mode: 'group' }, 'e1', [alice]);
-    StaticPartyService.join(sp, bob);
-    assert.deepEqual(StaticPartyService.missedIds(sp, bob.userId, NONE), ['e1']);
-  });
-
-  it('a connected participant who never joined the static party becomes a member on completion', () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS);
-    StaticPartyService.onItemCompleted({ staticPartyId: sp.id, mode: 'group' }, 'e1', [alice, bob]);
-    assert.deepEqual(sp.members[bob.userId]!.watchedItemIds, ['e1']);
-  });
-
-  it('a catch-up completion credits the participant without moving the group', () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS);
-    StaticPartyService.onItemCompleted({ staticPartyId: sp.id, mode: 'group' }, 'e1', [alice]);
-    StaticPartyService.join(sp, bob);
-
-    StaticPartyService.onItemCompleted({ staticPartyId: sp.id, mode: 'catchUp' }, 'e1', [bob]);
-
-    assert.deepEqual(StaticPartyService.missedIds(sp, bob.userId, NONE), []);
-    assert.equal(sp.group.nextIndex, 1, 'unchanged by a catch-up');
-    assert.deepEqual(sp.group.completedItemIds, ['e1']);
-  });
-
-  it('markWatched removes an item from the missed list, and refuses an unknown item', () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS);
-    StaticPartyService.onItemCompleted({ staticPartyId: sp.id, mode: 'group' }, 'e1', [alice]);
-    assert.equal(StaticPartyService.markWatched(sp, bob, 'e1'), true);
-    assert.deepEqual(StaticPartyService.missedIds(sp, bob.userId, NONE), []);
-    assert.equal(StaticPartyService.markWatched(sp, bob, 'nope'), false);
-  });
-
-  it('recordPosition only keeps a position for the group\'s next item, and a completion resets it', () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS);
-    const link = { staticPartyId: sp.id, mode: 'group' as const };
-    StaticPartyService.recordPosition(link, 'e3', 999);
-    assert.equal(sp.group.resumePositionTicks, 0, 'not the next item - ignored');
-    StaticPartyService.recordPosition(link, 'e1', 123);
-    assert.equal(sp.group.resumePositionTicks, 123);
-    StaticPartyService.recordPosition({ ...link, mode: 'catchUp' }, 'e1', 456);
-    assert.equal(sp.group.resumePositionTicks, 123, 'a catch-up session never moves the group');
-    StaticPartyService.onItemCompleted(link, 'e1', [alice]);
-    assert.equal(sp.group.resumePositionTicks, 0);
-  });
-
-  it('refreshItems appends new episodes without losing progress', () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS.slice(0, 2));
-    StaticPartyService.onItemCompleted({ staticPartyId: sp.id, mode: 'group' }, 'e1', [alice]);
-    StaticPartyService.refreshItems(sp, ITEMS);
-    assert.deepEqual(sp.items.map((i) => i.itemId), ['e1', 'e2', 'e3', 'e4']);
-    assert.equal(sp.group.nextIndex, 1);
-    assert.deepEqual(sp.group.completedItemIds, ['e1']);
-  });
-
-  it('only the creator can delete; leaving keeps the party', () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS);
-    StaticPartyService.join(sp, bob);
-    assert.equal(StaticPartyService.delete(sp, bob.userId), false);
-    StaticPartyService.leave(sp, bob.userId);
-    assert.ok(StaticPartyService.getById(sp.id));
-    assert.equal(StaticPartyService.delete(sp, alice.userId), true);
-    assert.equal(StaticPartyService.getById(sp.id), null);
-  });
-
-  it('onPartyDestroyed only clears the matching live session', () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS);
-    StaticPartyService.setLiveParty(sp, 'p1');
-    StaticPartyService.onPartyDestroyed({ staticPartyId: sp.id, mode: 'catchUp' }, 'p2');
-    assert.equal(sp.livePartyId, 'p1');
-    StaticPartyService.onPartyDestroyed({ staticPartyId: sp.id, mode: 'group' }, 'p1');
-    assert.equal(sp.livePartyId, null);
-  });
-
-  it('toDetail marks each item\'s group state and the viewer\'s own (in-app or Emby Played)', () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS);
-    StaticPartyService.onItemCompleted({ staticPartyId: sp.id, mode: 'group' }, 'e1', [alice]);
-    const detail = StaticPartyService.toDetail(sp, bob.userId, new Set(['e4']), null);
-    assert.deepEqual(detail.items.map((i) => i.groupState), ['watched', 'next', 'upcoming', 'upcoming']);
-    assert.deepEqual(detail.items.map((i) => i.viewerWatched), [false, false, false, true]);
-    assert.deepEqual(detail.missedItemIds, ['e1']);
-    assert.equal(detail.youAreMember, false);
-    assert.equal(detail.missedCount, 1);
-  });
-});
-
-describe('StaticPartyStore', () => {
-  it('writes one file per party, and round-trips it without runtime-only state', async () => {
-    const sp = StaticPartyService.create(alice, { type: 'playlist', sourceId: 'pl1' }, 'Soirées', '/img/pl1', ITEMS);
-    const other = StaticPartyService.create(bob, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS);
-    StaticPartyService.onItemCompleted({ staticPartyId: sp.id, mode: 'group' }, 'e1', [alice]);
-    StaticPartyService.setLiveParty(sp, 'live-1');
-    await StaticPartyStore.writeNow();
-
-    assert.deepEqual(fs.readdirSync(partiesDir()).sort(), [`${sp.id}.json`, `${other.id}.json`].sort());
-    const onDisk = JSON.parse(fs.readFileSync(path.join(partiesDir(), `${sp.id}.json`), 'utf8'));
-    assert.equal(onDisk.version, 1);
-    assert.equal('livePartyId' in onDisk.party, false);
-
-    StaticPartyService.init();
-    const reloaded = StaticPartyService.getById(sp.id)!;
-    assert.equal(reloaded.name, 'Soirées');
-    assert.deepEqual(reloaded.group.completedItemIds, ['e1']);
-    assert.equal(reloaded.livePartyId, null, 'a restart ends every live session');
-    assert.ok(StaticPartyService.getById(other.id));
-  });
-
-  it('a change only rewrites the party that changed', async () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'A', '/img/s1', ITEMS);
-    const other = StaticPartyService.create(bob, { type: 'series', sourceId: 's1' }, 'B', '/img/s1', ITEMS);
-    await StaticPartyStore.writeNow();
-    const otherFile = path.join(partiesDir(), `${other.id}.json`);
-    const past = new Date(Date.now() - 60000);
-    fs.utimesSync(otherFile, past, past);
-    // Compared against what the filesystem itself reports back, not
-    // past.getTime(): Linux returns mtimeMs as a float that can land a
-    // hair off the exact millisecond set (e.g. ...780.999 for ...781).
-    const mtimeBefore = fs.statSync(otherFile).mtimeMs;
-
-    StaticPartyService.markWatched(sp, alice, 'e1');
-    await StaticPartyStore.writeNow();
-
-    assert.equal(fs.statSync(otherFile).mtimeMs, mtimeBefore, 'the untouched party\'s file was not rewritten');
-  });
-
-  it('deleting a party removes its file, even with a save still pending', async () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'A', '/img/s1', ITEMS);
-    await StaticPartyStore.writeNow();
-    StaticPartyService.markWatched(sp, alice, 'e1'); // schedules a save...
-    StaticPartyService.delete(sp, alice.userId); // ...that must not recreate the file
-    await StaticPartyStore.writeNow();
-    assert.equal(fs.existsSync(path.join(partiesDir(), `${sp.id}.json`)), false);
-  });
-
-  it('a corrupt file is moved aside and only that party is lost', async () => {
-    const good = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'Good', '/img/s1', ITEMS);
-    await StaticPartyStore.writeNow();
-    fs.writeFileSync(path.join(partiesDir(), 'broken-id.json'), '{ not json', 'utf8');
-
-    StaticPartyService.init();
-
-    assert.deepEqual(StaticPartyService.list().map((p) => p.id), [good.id]);
-    assert.ok(fs.existsSync(path.join(partiesDir(), 'broken-id.json.corrupt')));
-  });
-
-  it('a leftover .tmp from an interrupted write is cleaned up, the real file kept', async () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'A', '/img/s1', ITEMS);
-    await StaticPartyStore.writeNow();
-    fs.writeFileSync(path.join(partiesDir(), `${sp.id}.json.tmp`), '{ half-writ', 'utf8');
-
-    StaticPartyService.init();
-
-    assert.ok(StaticPartyService.getById(sp.id));
-    assert.equal(fs.existsSync(path.join(partiesDir(), `${sp.id}.json.tmp`)), false);
-  });
-
-  it('migrates the first release\'s single static-parties.json into one file per party', () => {
-    const legacy = { version: 1, parties: [
-      { id: 'aaa-1', name: 'One', source: { type: 'series', sourceId: 's1' }, imageUrl: '', createdByUserId: 'u-alice', createdUtc: 1,
-        items: ITEMS, group: { nextIndex: 1, resumePositionTicks: 0, completedItemIds: ['e1'], lastSessionUtc: null }, members: {} },
-      { id: 'bbb-2', name: 'Two', source: { type: 'series', sourceId: 's1' }, imageUrl: '', createdByUserId: 'u-bob', createdUtc: 2,
-        items: ITEMS, group: { nextIndex: 0, resumePositionTicks: 0, completedItemIds: [], lastSessionUtc: null }, members: {} }
-    ] };
-    fs.writeFileSync(path.join(dataDir, 'static-parties.json'), JSON.stringify(legacy), 'utf8');
-
-    StaticPartyService.init();
-
-    assert.deepEqual(StaticPartyService.list().map((p) => p.id).sort(), ['aaa-1', 'bbb-2']);
-    assert.deepEqual(StaticPartyService.getById('aaa-1')!.group.completedItemIds, ['e1']);
-    assert.ok(fs.existsSync(path.join(partiesDir(), 'aaa-1.json')));
-    assert.equal(fs.existsSync(path.join(dataDir, 'static-parties.json')), false);
-    assert.ok(fs.existsSync(path.join(dataDir, 'static-parties.json.migrated')), 'the original is kept, not deleted');
-  });
-
-  it('an empty data directory is a normal first start', () => {
-    StaticPartyService.init();
-    assert.equal(StaticPartyService.list().length, 0);
-  });
-});
-
-describe('PartyService <-> static watch party', () => {
-  const connected = { emit() {}, disconnect() {} } as unknown as AppSocket;
-
-  it('advanceQueue credits the outgoing item to a linked static party, once', (t) => {
-    t.mock.method(PlaystateService, 'markPlayed', async () => {});
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS);
-    const party = PartyService.create(alice.userId, alice.userName, 'e1', 'Episode e1', '/img/e1', ITEMS, 'video');
-    party.staticLink = { staticPartyId: sp.id, mode: 'group' };
-    party.members.get(alice.userId)!.connection = connected;
-
-    PartyService.completeCurrentItem(party); // "itemEnded"...
-    PartyService.advanceQueue(party); // ...then "next" on the same item: must not double-count
-
-    assert.deepEqual(sp.group.completedItemIds, ['e1']);
-    assert.deepEqual(sp.members[alice.userId]!.watchedItemIds, ['e1']);
-    assert.equal(sp.group.nextIndex, 1);
-  });
-
-  it('an ordinary party never touches any static party', (t) => {
-    t.mock.method(PlaystateService, 'markPlayed', async () => {});
-    const completed = t.mock.method(StaticPartyService, 'onItemCompleted');
-    const party = PartyService.create(alice.userId, alice.userName, 'e1', 'Episode e1', '/img/e1', ITEMS, 'video');
-    party.members.get(alice.userId)!.connection = connected;
-    PartyService.advanceQueue(party);
-    assert.equal(completed.mock.callCount(), 0);
-  });
-
-  it('the last member leaving a group session clears the static party\'s live session', () => {
-    const sp = StaticPartyService.create(alice, { type: 'series', sourceId: 's1' }, 'My Show', '/img/s1', ITEMS);
-    const party = PartyService.create(alice.userId, alice.userName, 'e1', 'Episode e1', '/img/e1', ITEMS, 'video');
-    party.staticLink = { staticPartyId: sp.id, mode: 'group' };
-    StaticPartyService.setLiveParty(sp, party.id);
-    PartyService.leave(party, alice.userId);
-    assert.equal(sp.livePartyId, null);
-  });
-});

spec/static-watch-party.md

@@ -1,166 +0,0 @@
-# Lounge party (watch party statique)
-
-## Les trois types de party
-
-| Nom dans l'interface | Quoi | Où |
-|---|---|---|
-| **Watch party** | party vidéo classique, éphémère | accueil, « Parties en cours » |
-| **Listen party** | party audio classique, éphémère (barre musique) | accueil, « Parties en cours » |
-| **Lounge party** | party statique : une série ou une playlist vidéo suivie sur plusieurs séances | onglet « Lounge parties » |
-
-Côté code, la lounge party reste nommée « static party » (`StaticPartyService`,
-route `/static`, `staticLink`...). Seuls les libellés visibles ont changé. Sur
-l'accueil, chaque carte affiche un badge « Watch party » ou « Listen party ».
-
-## Objectif
-
-Suivre une série entière, ou une playlist vidéo, en groupe sur plusieurs
-soirées. L'app mémorise :
-
-- **l'avancement du groupe** : les éléments terminés ensemble, et où la
-  dernière séance s'est arrêtée ;
-- **l'avancement de chaque personne** : ce qu'elle a vu.
-
-Une personne qui revient ou qui rejoint en cours de route voit la liste de
-ce qu'elle a **manqué** et peut le rattraper.
-
-Contrairement à une watch party classique, qui vit en mémoire et disparaît
-avec son dernier membre, une watch party statique est **persistée sur
-disque** et survit aux redémarrages.
-
-## Modèle
-
-| Entité | Où | Rôle |
-|---|---|---|
-| `StaticParty` | `server/src/types.ts`, persistée | la « saison » du groupe : items, progression du groupe, membres |
-| `StaticPartyMember` | dans `StaticParty.members` | `watchedItemIds` = ce que la personne a vu dans l'app |
-| Séance | une `Party` live ordinaire + `party.staticLink` | la lecture elle-même : lecteur, sync, flux partagé et lobby réutilisés tels quels |
-
-`party.staticLink.mode` :
-
-- `group` : la séance du groupe. Un item terminé fait avancer le groupe
-  **et** est crédité à chaque participant connecté.
-- `catchUp` : un rattrapage. L'item est crédité aux participants connectés
-  uniquement, le groupe ne bouge pas.
-
-`party.hiddenFromLobby` : un rattrapage en solo n'apparaît pas dans la liste
-des watch parties en cours.
-
-## Règles
-
-- **Item terminé** :
-  - l'hôte passe à l'item suivant (`next`),
-  - ou le dernier item de la file se termine (`itemEnded`, nouvel event socket réservé à l'hôte).
-
-  Les deux passent par `PartyService.completeCurrentItem`, qui gère aussi le
-  flag `Played` d'Emby. Un même item n'est jamais compté deux fois de suite
-  (`lastCompletedItemId`). C'est la même heuristique que
-  `PlaystateService.markPlayed` : « le groupe est passé à la suite » vaut
-  « vu ».
-- **Seuls les membres connectés** au moment où l'item se termine sont
-  crédités. Une personne partie en cours d'épisode l'a donc manqué ; elle
-  peut le marquer comme vu.
-- **Manqués d'une personne** : les items terminés par le groupe, dans
-  l'ordre de la liste, moins ceux qu'elle a vus dans l'app
-  (`watchedItemIds`), moins ceux qu'Emby a déjà en `Played` pour son compte
-  (vus ailleurs). C'est la fonction pure `computeMissedIds`.
-- **Reprise** : le sweep existant des 20 s enregistre la position de l'hôte
-  (`group.resumePositionTicks`). La séance suivante démarre avec cette
-  position comme position de l'hôte, que `Player.ts` utilise déjà pour
-  placer la première image.
-- **Nouveaux épisodes** : chaque lecture de la page, et chaque lancement de
-  séance, recharge la source. Les nouveaux items sont ajoutés à la fin ; les
-  items retirés de la source sont conservés dans l'historique
-  (`mergeItemLists`).
-- **Accès** : ouverte à tous les comptes Emby.
-  - Rejoindre = devenir membre. Rejoindre la séance du groupe depuis le
-    lobby rend aussi membre de la watch party statique.
-  - N'importe quel membre peut lancer la séance ; celui qui la lance en
-    devient l'hôte.
-  - Quitter efface sa propre progression.
-  - Seul le créateur peut supprimer la watch party.
-- **Contenus** : une série entière, **une seule saison**, ou une playlist
-  vidéo. Une playlist musicale est refusée.
-  - Série entière : tous les épisodes de toutes les saisons à partir de S1E1.
-    Les spéciaux (saison 0) sont exclus : Emby les trie en premier, et une
-    séance commencerait par eux (`CatalogService.seriesQueueFrom`). Les
-    lounge parties créées avant ce changement gardent leurs spéciaux déjà
-    en liste.
-  - Saison : uniquement les épisodes de cette saison
-    (`CatalogService.seasonQueue`, par `SeasonId`, sinon par numéro de
-    saison). La source garde `seriesId` et `seasonNumber`, car les
-    épisodes sont récupérés par série puis filtrés. Nom par défaut :
-    « Série - Saison », avec l'affiche de la série.
-
-## API (`server/src/index.ts`)
-
-| Méthode | Route | Rôle |
-|---|---|---|
-| GET | `/api/static-parties` | liste, avec le nombre de manqués de l'utilisateur et la séance en cours |
-| POST | `/api/static-parties` | `{sourceId, name?}` : série, saison, épisode (sa série) ou playlist |
-| GET | `/api/static-parties/:id` | détail : items + état groupe / utilisateur, membres, `missedItemIds` |
-| POST | `/:id/join`, `/:id/leave` | devenir membre / quitter |
-| DELETE | `/:id` | supprimer (créateur uniquement) |
-| POST | `/:id/session` | lancer la séance du groupe, ou rejoindre celle en cours, puis renvoyer `{partyId}` |
-| POST | `/:id/items/:itemId/watched` | marquer comme vu |
-| POST | `/:id/catch-up` | `{itemIds, mode: 'solo'\|'party'}`, renvoie `{partyId}` |
-
-## Persistance
-
-- `StaticPartyStore` écrit **un fichier JSON par watch party** :
-  `${DATA_DIR}/static-parties/<id>.json`, au format `{version: 1, party}`.
-  - `DATA_DIR` vaut `./data` par défaut, et `/data` dans l'image Docker.
-    `docker-compose.yml` y monte `./data`.
-  - Un fichier par party limite les dégâts : une écriture ne touche que la
-    party modifiée, et un fichier corrompu ne coûte que cette party-là.
-  - L'écriture est atomique (`.tmp` puis `rename`) et debouncée (2 s) party
-    par party. Elle est flushée de façon synchrone sur `SIGTERM`/`SIGINT`.
-  - Au démarrage, un `.tmp` restant (écriture interrompue) est supprimé ; le
-    vrai fichier, s'il existe, est la dernière version complète.
-  - Un fichier corrompu (ou dont le nom ne correspond pas à l'id) est
-    renommé en `.corrupt` et ignoré ; les autres parties se chargent
-    normalement. Le serveur ne crashe jamais pour ça.
-  - Supprimer une party supprime son fichier et annule toute sauvegarde en
-    attente pour elle.
-  - Migration : l'ancien fichier unique `${DATA_DIR}/static-parties.json` de
-    la première version est éclaté en un fichier par party au premier
-    démarrage, puis renommé en `.migrated` (conservé, pas supprimé).
-- Pas de SQLite : l'image tourne en Node 20 (pas de `node:sqlite`), une
-  dépendance native serait une première dans l'image, et les données sont
-  minuscules.
-- `livePartyId` n'est jamais persisté : un redémarrage termine toutes les
-  séances, et la reprise se fait depuis la position enregistrée.
-
-## Client
-
-- `views/staticParty/` (route `/static/:id`) contient :
-  - l'en-tête, avec la progression du groupe et le bouton lancer / rejoindre
-    la séance ;
-  - « Tu as manqué », avec pour chaque élément cases à cocher, *Regarder en
-    solo* et *Marquer comme vu*, plus deux actions groupées : rattraper en
-    solo, ou lancer une watch party de rattrapage ;
-  - les membres ;
-  - la liste complète des items.
-- Page série (`views/series`) :
-  - en-tête : « Lancer toute la série » (watch party) et « Créer une lounge
-    party » (série entière) ;
-  - au-dessus des épisodes de l'onglet de saison sélectionné : « Lancer
-    cette saison » (watch party) et « Lounge party de cette saison ».
-- « Créer une lounge party » sur `views/playlist` (vidéo uniquement).
-- Onglet dédié « Lounge parties » (sidebar et menu mobile), route
-  `/static` (`views/staticParties/`) : une carte par watch party avec la
-  progression, le prochain élément, un badge « N manqués » et une pastille
-  « séance en cours ». L'onglet reste actif sur la page d'une party.
-- Séparation avec les watch/listen parties classiques : la liste « Parties
-  en cours » de l'accueil exclut les séances de lounge party
-  (`staticPartyId` non nul) ; elles ne s'affichent que dans leur onglet.
-
-## Limites connues
-
-- « Vu » reste une heuristique : passer à la suite compte comme vu, comme
-  pour le flag `Played` d'Emby. Il n'y a pas de seuil de pourcentage.
-- La liste et le détail relisent la source Emby à chaque affichage (une
-  requête par watch party pour la liste). C'est acceptable à l'échelle d'un
-  serveur perso ; à mettre en cache si la liste grossit.
-- Plusieurs watch parties statiques peuvent exister sur la même série
-  (des groupes différents) : c'est voulu, sans déduplication.