diff --git a/apps/api/middleware/security.ts b/apps/api/middleware/security.ts
index a9e61370..9b313224 100644
--- a/apps/api/middleware/security.ts
+++ b/apps/api/middleware/security.ts
@@ -4,7 +4,12 @@
  * Implements request validation, suspicious activity detection, and security headers
  */
 
-import { detectDDoS, isBlacklisted, getClientIP } from '~~/utils/rateLimit';
+import {
+  detectDDoS,
+  isBlacklisted,
+  getClientIP,
+  isInternalOrigin,
+} from '~~/utils/rateLimit';
 import { eq } from 'drizzle-orm';
 import { db } from '@trackarr/db';
 import { users, webauthnCredentials } from '@trackarr/db/schema';
@@ -173,6 +178,24 @@ export default defineEventHandler(async (event) => {
   const ip = getClientIP(event);
   const userAgent = getHeader(event, 'user-agent') || '';
 
+  /*
+   * Notre propre rendu serveur n'est pas un client.
+   *
+   * Le compteur anti-abus est par adresse, et le conteneur web n'en a qu'une
+   * pour tout le site : QUATRE requêtes par page vue s'y accumulaient
+   * (mesuré), donc vingt-cinq pages en dix secondes suffisaient à bannir
+   * l'instance entière. Le filtre est décrit dans `isInternalOrigin` — pair
+   * socket privé ET aucun en-tête de transfert, deux conditions qu'un client
+   * d'Internet ne peut pas réunir.
+   *
+   * Ce que ça n'exempte PAS : le filtre d'agent, la validation de chemin et de
+   * paramètres, les bannissements d'adresse, les limites par route et toute
+   * la suite de l'authentification. Uniquement le compteur grossier et la
+   * liste noire qu'il alimente — c'est-à-dire exactement ce qui n'a aucun sens
+   * pour une instance qui se parle à elle-même.
+   */
+  const interne = isInternalOrigin(event);
+
   // Order matters. Everything below is sorted by cost, cheapest first, so a
   // flood is dropped as early as possible:
   //
@@ -208,15 +231,16 @@ export default defineEventHandler(async (event) => {
   }
 
   // 2. Redis — temporary blacklist, then the abuse counter itself.
-  if (await isBlacklisted(ip)) {
+  if (!interne && (await isBlacklisted(ip))) {
     console.warn(`[Security] Blocked blacklisted IP: ${ip.slice(0, 8)}...`);
     throw createError({ statusCode: 403, message: 'Access denied' });
   }
 
   if (
-    path.startsWith('/api/') ||
-    path.includes('/announce') ||
-    path.includes('/scrape')
+    !interne &&
+    (path.startsWith('/api/') ||
+      path.includes('/announce') ||
+      path.includes('/scrape'))
   ) {
     await detectDDoS(event);
   }
diff --git a/apps/api/plugins/metadata-warmer.ts b/apps/api/plugins/metadata-warmer.ts
new file mode 100644
index 00000000..c19e28ea
--- /dev/null
+++ b/apps/api/plugins/metadata-warmer.ts
@@ -0,0 +1,114 @@
+import { db, schema } from '@trackarr/db';
+import { and, desc, eq, isNotNull, or } from 'drizzle-orm';
+import { redis } from '~~/utils/server';
+import { withCronLock } from '~~/utils/cronLock';
+import {
+  isMetadataEnabled,
+  isSourceEnabled,
+  lookupMetadata,
+  normalizeSourceId,
+  type LookupSource,
+} from '~~/utils/metadata';
+import type { MediaTypeHint } from '~~/utils/metadata/types';
+
+/**
+ * Préchauffer le cache des œuvres.
+ *
+ * Le catalogue ne lit que le cache des métadonnées : une œuvre dont personne
+ * n'a ouvert la fiche s'affiche par son nom de fichier, sans affiche ni titre.
+ * Cette tâche comble le trou à petite cadence — UNE recherche amont par tic,
+ * vingt secondes entre deux par défaut — en partant des torrents les plus
+ * récents. Ce qu'elle a tenté (trouvé ou non) est marqué sept jours dans un
+ * ensemble Redis, pour ne pas retaper à la même porte.
+ *
+ * Elle respecte les mêmes gardes que la fiche : pas de fournisseur configuré,
+ * pas d'appel ; une panne amont est déjà mise en cache court par `guarded`.
+ */
+const INTERVAL_MS = Math.max(5000, parseInt(process.env.METADATA_WARM_INTERVAL_MS || '20000', 10) || 20000);
+const FIRST_RUN_DELAY_MS = 45_000;
+const CANDIDATES = 300;
+/*
+ * Un marqueur PAR ŒUVRE, et non un ensemble.
+ *
+ * `EXPIRE` porte sur la clé entière : avec un `SADD` suivi d'un `EXPIRE`, chaque
+ * nouveau marquage repoussait le délai de TOUT l'ensemble. Le collecteur
+ * marquant une œuvre toutes les vingt secondes, l'ensemble n'expirait jamais et
+ * une œuvre en échec n'était jamais reprise — le défaut qu'on croyait corriger.
+ */
+const MARK_PREFIX = 'meta:warm:v2:';
+const markKey = (key: string) => `${MARK_PREFIX}${key}`;
+const DONE_TTL_S = 7 * 86400;
+/** Les œuvres tentées sans réponse (amont en panne, dépassement) : on y revient dans l'heure, pas dans la semaine. */
+const RETRY_TTL_S = 3600;
+
+type Ref = { source: LookupSource; id: string; hint: MediaTypeHint | undefined };
+
+function refOf(row: { tmdbId: string | null; igdbId: string | null; openlibraryId: string | null }): Ref | null {
+  if (row.tmdbId) {
+    const hint = row.tmdbId.startsWith('tv/') ? 'tv' : row.tmdbId.startsWith('movie/') ? 'movie' : undefined;
+    return { source: 'tmdb', id: row.tmdbId, hint };
+  }
+  if (row.igdbId) return { source: 'igdb', id: row.igdbId, hint: 'game' };
+  if (row.openlibraryId) return { source: 'openlibrary', id: row.openlibraryId, hint: 'book' };
+  return null;
+}
+
+async function tick(): Promise<void> {
+  if (!isMetadataEnabled()) return;
+  const rows = await db
+    .select({ tmdbId: schema.torrents.tmdbId, igdbId: schema.torrents.igdbId, openlibraryId: schema.torrents.openlibraryId })
+    .from(schema.torrents)
+    .where(
+      and(
+        eq(schema.torrents.moderationStatus, 'accepted'),
+        eq(schema.torrents.isActive, true),
+        or(isNotNull(schema.torrents.tmdbId), isNotNull(schema.torrents.igdbId), isNotNull(schema.torrents.openlibraryId)),
+      ),
+    )
+    .orderBy(desc(schema.torrents.createdAt))
+    .limit(CANDIDATES);
+  const candidates = rows
+    .map((row) => refOf(row))
+    .filter((ref): ref is Ref => !!ref)
+    .map((ref) => ({ ref, key: `${ref.source}:${ref.id}` }));
+  if (candidates.length === 0) return;
+  // Une lecture pour toute la fenêtre : chaque marqueur porte son propre délai.
+  const marks = await redis.mget(...candidates.map((c) => markKey(c.key)));
+  const mark = (key: string, ttl: number) => redis.set(markKey(key), '1', 'EX', ttl);
+  for (const [i, { ref, key }] of candidates.entries()) {
+    if (marks[i]) continue;
+    if (!isSourceEnabled(ref.source)) {
+      await mark(key, DONE_TTL_S);
+      continue;
+    }
+    const canonical = await normalizeSourceId(ref.source, ref.id);
+    if (!canonical) {
+      await mark(key, DONE_TTL_S);
+      continue;
+    }
+    // « Fait » seulement sur une réponse ; une panne amont marquait l'œuvre
+    // faite pour sept jours, et rien ne la redemandait avant qu'un membre
+    // n'ouvre sa fiche. `lookupMetadata` rend null sur amont indisponible
+    // comme sur 404 : dans le doute, on repasse dans l'heure.
+    let meta: unknown = null;
+    try {
+      meta = await lookupMetadata(ref.source, canonical, ref.hint);
+    } catch (err) {
+      console.warn('[MetadataWarmer] lookup failed for', key, ':', (err as Error).message);
+    }
+    await mark(key, meta ? DONE_TTL_S : RETRY_TTL_S);
+    return; // une œuvre par tic : la cadence est la protection des quotas
+  }
+}
+
+export default defineNitroPlugin(() => {
+  const run = async () => {
+    try {
+      await withCronLock('metadata_warmer:lock', 60, tick);
+    } catch (err) {
+      console.warn('[MetadataWarmer] tick failed:', (err as Error).message);
+    }
+  };
+  setTimeout(run, FIRST_RUN_DELAY_MS).unref?.();
+  setInterval(run, INTERVAL_MS).unref?.();
+});
diff --git a/apps/api/plugins/stats-collector.ts b/apps/api/plugins/stats-collector.ts
index 37d8eaba..12951989 100644
--- a/apps/api/plugins/stats-collector.ts
+++ b/apps/api/plugins/stats-collector.ts
@@ -115,6 +115,28 @@ async function writeTorrentStats(
            SET seeders = 0, leechers = 0, updated_at = now()
          WHERE (seeders <> 0 OR leechers <> 0)
            AND updated_at < ${passStartedAt}::timestamptz`);
+
+      // L'historique : un point par torrent et par jour, la dernière valeur du
+      // jour l'emporte. Lu depuis `torrent_stats` et non depuis `perTorrent`,
+      // pour que les rangées que le balayage ci-dessus vient de METTRE À ZÉRO
+      // soient enregistrées elles aussi — un essaim qui meurt est précisément
+      // ce que la courbe doit montrer. `updated_at >= passStartedAt` borne la
+      // copie à ce que cette passe a touché.
+      //
+      // Seulement après une passe COMPLÈTE : un balayage tronqué a vu un
+      // sous-ensemble arbitraire, et un jour manquant vaut mieux qu'un jour
+      // faux.
+      await db.execute(sql`
+        INSERT INTO torrent_stats_history (info_hash, day, seeders, leechers)
+        SELECT info_hash, current_date, seeders, leechers
+          FROM torrent_stats
+         WHERE updated_at >= ${passStartedAt}::timestamptz
+            ON CONFLICT (info_hash, day) DO UPDATE
+           SET seeders = excluded.seeders,
+               leechers = excluded.leechers`);
+      await db.execute(sql`
+        DELETE FROM torrent_stats_history
+         WHERE day < current_date - 30`);
     }
   } catch (err) {
     // A stale snapshot degrades a range on a collapsed row; it must never
diff --git a/apps/api/routes/api/admin/categories/[id]/merge.post.ts b/apps/api/routes/api/admin/categories/[id]/merge.post.ts
new file mode 100644
index 00000000..b0d68fa6
--- /dev/null
+++ b/apps/api/routes/api/admin/categories/[id]/merge.post.ts
@@ -0,0 +1,98 @@
+import { eq } from 'drizzle-orm';
+import { z } from 'zod';
+import { db, schema } from '@trackarr/db';
+import { requireAdminSession } from '~~/utils/adminAuth';
+import { validateBody } from '~~/utils/schemas';
+import { auditDetail } from '~~/utils/audit';
+
+/**
+ * POST /api/admin/categories/:id/merge — fondre une catégorie dans une autre.
+ *
+ * Un import laisse « Films » et « Movies », « Jeux » et « Games » : deux
+ * facettes pour une seule chose, et un catalogue qui compte double. Tout ce
+ * qui pointait la source pointe la cible — torrents, sous-catégories,
+ * recherches enregistrées, demandes, motifs des règles d'envoi, table de
+ * correspondance fédérée — puis la source disparaît. Une transaction : pas de
+ * catalogue à moitié déplacé.
+ */
+const bodySchema = z.object({ into: z.string().uuid() });
+
+export default defineEventHandler(async (event) => {
+  await requireAdminSession(event);
+  const id = getRouterParam(event, 'id');
+  if (!id || !z.string().uuid().safeParse(id).success) throw createError({ statusCode: 400, message: 'Category ID is required' });
+  const { into } = await validateBody(event, bodySchema);
+  if (into === id) throw createError({ statusCode: 400, message: 'A category cannot be merged into itself' });
+
+  const [source, target] = await Promise.all([
+    db.query.categories.findFirst({ where: eq(schema.categories.id, id) }),
+    db.query.categories.findFirst({ where: eq(schema.categories.id, into) }),
+  ]);
+  if (!source || !target) throw createError({ statusCode: 404, message: 'Category not found' });
+  if (target.parentId === id) {
+    throw createError({ statusCode: 400, message: 'The target is a child of the source; merge the other way round' });
+  }
+  // Le drapeau adulte suit la catégorie : fondre une catégorie adulte dans une
+  // catégorie ordinaire montrerait ses torrents à qui a coupé ce contenu.
+  if (source.isAdult !== target.isAdult) {
+    throw createError({ statusCode: 400, message: 'The adult flag differs between the two categories' });
+  }
+  // La cible ne descend pas de la source (à toute profondeur : sinon un cycle),
+  // et une source qui a des enfants ne peut fondre que dans une racine, pour
+  // que l'arbre garde ses deux niveaux — le listing ne déplie qu'un niveau.
+  const children = await db.query.categories.findMany({ where: eq(schema.categories.parentId, id), columns: { id: true } });
+  if (children.length > 0 && target.parentId) {
+    throw createError({ statusCode: 400, message: 'A category with sub-categories can only be merged into a root category' });
+  }
+  // Toute la chaîne, jusqu'à la racine — un compteur de bonds laissait passer
+  // un arbre plus profond que la limite. Le jeu des visités arrête un cycle
+  // préexistant sans borne arbitraire.
+  const walked = new Set<string>();
+  for (let cursor = target.parentId; cursor && !walked.has(cursor); ) {
+    if (cursor === id) throw createError({ statusCode: 400, message: 'The target descends from the source' });
+    walked.add(cursor);
+    const parent = await db.query.categories.findFirst({ where: eq(schema.categories.id, cursor), columns: { parentId: true } });
+    cursor = parent?.parentId ?? null;
+  }
+
+  const moved = await db.transaction(async (tx) => {
+    const torrents = await tx
+      .update(schema.torrents)
+      .set({ categoryId: into })
+      .where(eq(schema.torrents.categoryId, id))
+      .returning({ id: schema.torrents.id });
+    await tx.update(schema.categories).set({ parentId: into }).where(eq(schema.categories.parentId, id));
+    await tx.update(schema.savedSearches).set({ categoryId: into }).where(eq(schema.savedSearches.categoryId, id));
+    await tx.update(schema.uploadRequests).set({ categoryId: into }).where(eq(schema.uploadRequests.categoryId, id));
+    // Un motif d'envoi par catégorie (clé primaire) : si la cible a déjà le
+    // sien, il l'emporte et celui de la source part avec elle ; sinon il suit.
+    const [targetPattern] = await tx
+      .select({ categoryId: schema.uploadRuleCategoryPatterns.categoryId })
+      .from(schema.uploadRuleCategoryPatterns)
+      .where(eq(schema.uploadRuleCategoryPatterns.categoryId, into))
+      .limit(1);
+    if (targetPattern) {
+      await tx.delete(schema.uploadRuleCategoryPatterns).where(eq(schema.uploadRuleCategoryPatterns.categoryId, id));
+    } else {
+      await tx
+        .update(schema.uploadRuleCategoryPatterns)
+        .set({ categoryId: into })
+        .where(eq(schema.uploadRuleCategoryPatterns.categoryId, id));
+    }
+    await tx
+      .update(schema.remoteCategoryMap)
+      .set({ localCategoryId: into })
+      .where(eq(schema.remoteCategoryMap.localCategoryId, id));
+    await tx.delete(schema.categories).where(eq(schema.categories.id, id));
+    return torrents.length;
+  });
+
+  invalidateAdultCategoryCache();
+  auditDetail(event, {
+    action: 'categories.merge',
+    targetType: 'category',
+    targetId: id,
+    changes: { from: source.name, into: target.name, torrentsMoved: moved },
+  });
+  return { success: true, moved };
+});
diff --git a/apps/api/routes/api/admin/search-misses/index.delete.ts b/apps/api/routes/api/admin/search-misses/index.delete.ts
new file mode 100644
index 00000000..5358185e
--- /dev/null
+++ b/apps/api/routes/api/admin/search-misses/index.delete.ts
@@ -0,0 +1,30 @@
+import { eq } from 'drizzle-orm';
+import { z } from 'zod';
+import { db, schema } from '@trackarr/db';
+import { requireAdminSession } from '~~/utils/adminAuth';
+import { auditDetail } from '~~/utils/audit';
+
+/**
+ * DELETE /api/admin/search-misses — effacer une ligne, ou tout.
+ *
+ * Une recherche qu'on a traitée (la release est arrivée, ou n'existe pas)
+ * sort de la liste ; sans corps, la liste repart de zéro.
+ */
+const bodySchema = z.object({ query: z.string().trim().min(1).max(200).optional() });
+
+export default defineEventHandler(async (event) => {
+  await requireAdminSession(event);
+  const raw = await readBody(event).catch(() => ({}));
+  const parsed = bodySchema.safeParse(raw ?? {});
+  if (!parsed.success) throw createError({ statusCode: 400, message: 'query: 1 to 200 characters' });
+  const body = parsed.data;
+  const deleted = body.query
+    ? await db.delete(schema.searchMisses).where(eq(schema.searchMisses.query, body.query.toLowerCase())).returning({ q: schema.searchMisses.query })
+    : await db.delete(schema.searchMisses).returning({ q: schema.searchMisses.query });
+  auditDetail(event, {
+    action: 'search_misses.clear',
+    targetType: 'search_misses',
+    changes: { query: body.query ?? '*', deleted: deleted.length },
+  });
+  return { success: true, deleted: deleted.length };
+});
diff --git a/apps/api/routes/api/admin/search-misses/index.get.ts b/apps/api/routes/api/admin/search-misses/index.get.ts
new file mode 100644
index 00000000..3dbc7f21
--- /dev/null
+++ b/apps/api/routes/api/admin/search-misses/index.get.ts
@@ -0,0 +1,26 @@
+import { desc } from 'drizzle-orm';
+import { z } from 'zod';
+import { db, schema } from '@trackarr/db';
+import { requireAdminSession } from '~~/utils/adminAuth';
+import { validateQuery } from '~~/utils/schemas';
+
+/**
+ * GET /api/admin/search-misses — ce que les membres cherchent en vain.
+ *
+ * Les plus fréquentes d'abord, puis les plus récentes : c'est une liste
+ * d'acquisition, et le haut de la liste est ce qui manque le plus.
+ */
+const querySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(500).default(100),
+});
+
+export default defineEventHandler(async (event) => {
+  await requireAdminSession(event);
+  const { limit } = validateQuery(event, querySchema);
+  const items = await db
+    .select()
+    .from(schema.searchMisses)
+    .orderBy(desc(schema.searchMisses.count), desc(schema.searchMisses.lastAt))
+    .limit(limit);
+  return { items };
+});
diff --git a/apps/api/routes/api/admin/settings.get.ts b/apps/api/routes/api/admin/settings.get.ts
index 113577b9..d28effb2 100644
--- a/apps/api/routes/api/admin/settings.get.ts
+++ b/apps/api/routes/api/admin/settings.get.ts
@@ -1,6 +1,10 @@
 import { requireAdminSession } from '~~/utils/adminAuth';
 import {
   getSetting,
+  getCatalogueSettings,
+  isHnrEnabled,
+  getHnrRequiredSeedTime,
+  getHnrGracePeriod,
   getMessagingDmScope,
   getMessagingRoomScope,
   getDmRetentionDays,
@@ -68,6 +72,11 @@ export default defineEventHandler(async (event) => {
   const registrationOpen = await isRegistrationOpen();
   const minRatio = await getMinRatio();
   const starterUpload = await getStarterUpload();
+  const hnrEnabled = await isHnrEnabled();
+  // Secondes en base, heures pour l'interface — arrondi à l'heure, ce que le
+  // formulaire sait écrire.
+  const hnrRequiredSeedHours = Math.round((await getHnrRequiredSeedTime()) / 3600);
+  const hnrGraceHours = Math.round((await getHnrGracePeriod()) / 3600);
   const siteName = await getSiteName();
   const siteLogo = await getSiteLogo();
   const siteLogoImage = await getSiteLogoImage();
@@ -110,6 +119,7 @@ export default defineEventHandler(async (event) => {
     await getSetting(SEARCH_FIELDS_SETTING)
   );
   const searchFuzzy = parseSearchFuzzy(await getSetting(SEARCH_FUZZY_SETTING));
+  const catalogue = await getCatalogueSettings();
   const requestAutoValidateHours = await getRequestAutoValidateHours();
   const requestMaxFillsPerUser = await getRequestMaxFillsPerUser();
   const templateQuotaPerUser = await getTemplateQuotaPerUser();
@@ -140,6 +150,9 @@ export default defineEventHandler(async (event) => {
     registrationOpen,
     minRatio,
     starterUpload,
+    hnrEnabled,
+    hnrRequiredSeedHours,
+    hnrGraceHours,
     siteName,
     siteLogo,
     siteLogoImage,
@@ -178,5 +191,9 @@ export default defineEventHandler(async (event) => {
     templateQuotaPerUser,
     searchFields,
     searchFuzzy,
+    catalogueDefaultView: catalogue.defaultView,
+    catalogueDefaultSort: catalogue.defaultSort,
+    cataloguePageSize: catalogue.pageSize,
+    catalogueFacets: catalogue.facets,
   };
 });
diff --git a/apps/api/routes/api/admin/settings.put.ts b/apps/api/routes/api/admin/settings.put.ts
index 1cf8cb2d..d1529d69 100644
--- a/apps/api/routes/api/admin/settings.put.ts
+++ b/apps/api/routes/api/admin/settings.put.ts
@@ -57,6 +57,19 @@ export default defineEventHandler(async (event) => {
     );
   }
 
+  if (body.catalogueDefaultView !== undefined) {
+    await setSetting(SETTINGS_KEYS.CATALOGUE_DEFAULT_VIEW, body.catalogueDefaultView);
+  }
+  if (body.catalogueDefaultSort !== undefined) {
+    await setSetting(SETTINGS_KEYS.CATALOGUE_DEFAULT_SORT, body.catalogueDefaultSort);
+  }
+  if (body.cataloguePageSize !== undefined) {
+    await setSetting(SETTINGS_KEYS.CATALOGUE_PAGE_SIZE, String(body.cataloguePageSize));
+  }
+  if (body.catalogueFacets !== undefined) {
+    await setSetting(SETTINGS_KEYS.CATALOGUE_FACETS, [...new Set(body.catalogueFacets)].join(','));
+  }
+
   if (typeof body.registrationOpen === 'boolean') {
     await setRegistrationOpen(body.registrationOpen);
   }
@@ -79,6 +92,23 @@ export default defineEventHandler(async (event) => {
     await setSetting(SETTINGS_KEYS.MIN_RATIO, body.minRatio.toString());
   }
 
+  // Hit & Run : les trois réglages que le tracker lit déjà (`cache.go`,
+  // `KeyHnr*`) et que l'API applique à la création de chaque ligne — mais
+  // qu'aucune interface n'exposait : le seuil de 24 h était modifiable en base
+  // seulement, et la doc affirmait le contraire.
+  if (typeof body.hnrEnabled === 'boolean') {
+    await setSetting(SETTINGS_KEYS.HNR_ENABLED, String(body.hnrEnabled));
+  }
+  if (typeof body.hnrRequiredSeedHours === 'number') {
+    await setSetting(
+      SETTINGS_KEYS.HNR_REQUIRED_SEED_TIME,
+      String(body.hnrRequiredSeedHours * 3600)
+    );
+  }
+  if (typeof body.hnrGraceHours === 'number') {
+    await setSetting(SETTINGS_KEYS.HNR_GRACE_PERIOD, String(body.hnrGraceHours * 3600));
+  }
+
   if (typeof body.starterUpload === 'number') {
     await setSetting(
       SETTINGS_KEYS.STARTER_UPLOAD,
diff --git a/apps/api/routes/api/branding.get.ts b/apps/api/routes/api/branding.get.ts
index 5f6a8154..208706c1 100644
--- a/apps/api/routes/api/branding.get.ts
+++ b/apps/api/routes/api/branding.get.ts
@@ -21,6 +21,7 @@ import {
   type ServableTheme,
 } from '~~/utils/themes';
 import { resolveTokens } from '@trackarr/shared/theme';
+import { getCatalogueSettings } from '~~/utils/settings';
 
 /**
  * GET /api/branding
@@ -105,6 +106,7 @@ export default defineEventHandler(async (event) => {
     ? choosableFor(allThemes, userId ? await roleIdsFor(userId) : [])
     : allThemes;
   const themeDefault = await getDefaultTheme();
+  const catalogue = await getCatalogueSettings();
 
   return {
     siteName,
@@ -121,6 +123,9 @@ export default defineEventHandler(async (event) => {
     // False when federation was never configured, which is the same answer as
     // configured-and-off for anything the browser does with it.
     federationEnabled,
+    // Les réglages du catalogue : la page en a besoin avant tout appel signé,
+    // et ils sont publics à tout membre — même enveloppe que le reste.
+    catalogue,
     themeDefault,
     // No `visibility` / `requiredRoles`: the list is already filtered, and
     // publishing which role unlocks which theme is information the picker has
diff --git a/apps/api/routes/api/me/index.get.ts b/apps/api/routes/api/me/index.get.ts
index 40236f04..8193e69a 100644
--- a/apps/api/routes/api/me/index.get.ts
+++ b/apps/api/routes/api/me/index.get.ts
@@ -37,6 +37,7 @@ export default defineEventHandler(async (event) => {
       shareReputationFederated: true,
       theme: true,
       language: true,
+      catalogueDefaults: true,
       createdAt: true,
       lastSeen: true,
     },
@@ -121,6 +122,7 @@ export default defineEventHandler(async (event) => {
     shareReputationFederated: user.shareReputationFederated,
     theme: user.theme,
     language: user.language,
+    catalogueDefaults: user.catalogueDefaults ?? null,
     createdAt: user.createdAt,
     lastSeen: user.lastSeen,
     counts: {
diff --git a/apps/api/routes/api/me/index.patch.ts b/apps/api/routes/api/me/index.patch.ts
index acb39c2d..382834d1 100644
--- a/apps/api/routes/api/me/index.patch.ts
+++ b/apps/api/routes/api/me/index.patch.ts
@@ -89,6 +89,9 @@ const bodySchema = z
     // is free-form so historical rows referencing a removed locale
     // are still readable (they fall back to `defaultLocale` at boot).
     language: z.enum(['en', 'fr']).optional(),
+    // Les filtres par défaut du catalogue, sous la forme de sa chaîne de requête
+    // (clés courtes, valeurs courtes) ; null pour les retirer.
+    catalogueDefaults: z.record(z.string().max(16), z.string().max(200)).nullable().optional(),
   })
   .strict();
 
@@ -111,6 +114,7 @@ export default defineEventHandler(async (event) => {
     shareReputationFederated: boolean;
     theme: string | null;
     language: 'en' | 'fr';
+    catalogueDefaults: Record<string, string> | null;
   }> = {};
 
   if (body.displayName !== undefined) {
@@ -169,6 +173,13 @@ export default defineEventHandler(async (event) => {
   if (body.language !== undefined) {
     updates.language = body.language;
   }
+  if (body.catalogueDefaults !== undefined) {
+    const entries = body.catalogueDefaults ? Object.entries(body.catalogueDefaults) : [];
+    if (entries.length > 12) {
+      throw createError({ statusCode: 400, message: 'Too many catalogue defaults' });
+    }
+    updates.catalogueDefaults = entries.length ? Object.fromEntries(entries) : null;
+  }
 
   if (Object.keys(updates).length === 0) {
     // Nothing to do — return 200 with current state rather than 400 so
@@ -191,6 +202,7 @@ export default defineEventHandler(async (event) => {
       shareReputationFederated: schema.users.shareReputationFederated,
       theme: schema.users.theme,
       language: schema.users.language,
+      catalogueDefaults: schema.users.catalogueDefaults,
     });
 
   if (!updated) {
diff --git a/apps/api/routes/api/me/saved-searches/[id]/seen.post.ts b/apps/api/routes/api/me/saved-searches/[id]/seen.post.ts
new file mode 100644
index 00000000..d6f388ce
--- /dev/null
+++ b/apps/api/routes/api/me/saved-searches/[id]/seen.post.ts
@@ -0,0 +1,29 @@
+import { and, eq, sql } from 'drizzle-orm';
+import { db, schema } from '@trackarr/db';
+import { requireAuthSession } from '~~/utils/adminAuth';
+import { rateLimit, RATE_LIMITS } from '~~/utils/rateLimit';
+import { uuidSchema, validateParam } from '~~/utils/schemas';
+
+/**
+ * POST /api/me/saved-searches/:id/seen — « j'ai vu ».
+ *
+ * Le bandeau d'alertes du catalogue affiche « n nouv. » : les correspondances
+ * arrivées depuis la dernière fois que le membre a ouvert cette recherche
+ * depuis là. Ouvrir, c'est voir : `seen_count` rejoint `match_count`.
+ */
+export default defineEventHandler(async (event) => {
+  const { user } = await requireAuthSession(event);
+  await rateLimit(event, RATE_LIMITS.mutation);
+  const id = validateParam(event, 'id', uuidSchema);
+
+  const rows = await db
+    .update(schema.savedSearches)
+    .set({ seenCount: sql`${schema.savedSearches.matchCount}` })
+    .where(and(eq(schema.savedSearches.id, id), eq(schema.savedSearches.userId, user.id)))
+    .returning({ seenCount: schema.savedSearches.seenCount });
+
+  if (rows.length === 0) {
+    throw createError({ statusCode: 404, message: 'Saved search not found' });
+  }
+  return { seenCount: rows[0]!.seenCount };
+});
diff --git a/apps/api/routes/api/me/saved-searches/index.post.ts b/apps/api/routes/api/me/saved-searches/index.post.ts
index d7e85aac..40452d63 100644
--- a/apps/api/routes/api/me/saved-searches/index.post.ts
+++ b/apps/api/routes/api/me/saved-searches/index.post.ts
@@ -38,6 +38,13 @@ const bodySchema = z.object({
   tmdbId: z.string().max(64).optional(),
   tvdbId: z.string().max(64).optional(),
   notify: z.boolean().optional(),
+  // Ce que la barre du catalogue produit : groupes d'étiquettes (« hevc,x265;1080p »),
+  // saison, épisode, année, uploadeur (nom, résolu en id ici).
+  tagGroups: z.string().max(400).optional(),
+  season: z.number().int().min(0).max(999).optional(),
+  episode: z.number().int().min(0).max(9999).optional(),
+  year: z.number().int().min(1900).max(2100).optional(),
+  uploader: z.string().trim().min(1).max(64).optional(),
 });
 
 export default defineEventHandler(async (event) => {
@@ -56,8 +63,33 @@ export default defineEventHandler(async (event) => {
 
   // `query` without a usable tsquery means the member typed only punctuation —
   // it looks like a criterion and matches nothing, so it does not count as one.
+  const tagGroups =
+    body.tagGroups
+      ?.split(';')
+      .map((g) => Array.from(new Set(g.split(',').map(slugifyTag).filter(Boolean))).join(','))
+      .filter(Boolean)
+      .join(';') || null;
+  const season = body.season ?? null;
+  const episode = body.episode ?? null;
+  const year = body.year ?? null;
+  let uploaderId: string | null = null;
+  if (body.uploader) {
+    const [u] = await db
+      .select({ id: schema.users.id, anonymousUploads: schema.users.anonymousUploads })
+      .from(schema.users)
+      .where(sql`lower(${schema.users.username}) = ${body.uploader.toLowerCase()}`)
+      .limit(1);
+    // Un membre inconnu, ou un membre qui a choisi les envois anonymes (sauf pour
+    // lui-même et l'équipe) : la même réponse, pour ne pas dire lequel des deux.
+    const isStaff = !!((user as { isAdmin?: boolean }).isAdmin || (user as { isModerator?: boolean }).isModerator);
+    const allowed = !!u && (!u.anonymousUploads || u.id === user.id || isStaff);
+    if (!allowed) throw createError({ statusCode: 400, message: 'uploader: unknown member' });
+    uploaderId = u.id;
+  }
+
   const hasCriteria =
-    !!tsquery || !!categoryId || tags.length > 0 || !!imdbId || !!tmdbId || !!tvdbId;
+    !!tsquery || !!categoryId || tags.length > 0 || !!imdbId || !!tmdbId || !!tvdbId ||
+    !!tagGroups || season !== null || episode !== null || year !== null || !!uploaderId;
   if (!hasCriteria) {
     throw createError({
       statusCode: 400,
@@ -106,10 +138,12 @@ export default defineEventHandler(async (event) => {
    */
   const inserted = await db.execute(sql`
     insert into ${schema.savedSearches}
-      (id, user_id, label, query, tsquery, category_id, tags, imdb_id, tmdb_id, tvdb_id, notify)
+      (id, user_id, label, query, tsquery, category_id, tags, imdb_id, tmdb_id, tvdb_id, notify,
+       tag_groups, season, episode, year, uploader_id)
     select
       ${id}, ${user.id}, ${body.label}, ${query}, ${tsquery}, ${categoryId},
-      ${tagsJson}::jsonb, ${imdbId}, ${tmdbId}, ${tvdbId}, ${body.notify ?? true}
+      ${tagsJson}::jsonb, ${imdbId}, ${tmdbId}, ${tvdbId}, ${body.notify ?? true},
+      ${tagGroups}, ${season}, ${episode}, ${year}, ${uploaderId}
     where (
       select count(*) from ${schema.savedSearches}
       where ${schema.savedSearches.userId} = ${user.id}
diff --git a/apps/api/routes/api/metadata/tint.post.ts b/apps/api/routes/api/metadata/tint.post.ts
new file mode 100644
index 00000000..8ec57ec8
--- /dev/null
+++ b/apps/api/routes/api/metadata/tint.post.ts
@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { redis } from '~~/utils/server';
+import { rateLimit, RATE_LIMITS } from '~~/utils/rateLimit';
+import { validateBody } from '~~/utils/schemas';
+import { db, schema } from '@trackarr/db';
+import { eq } from 'drizzle-orm';
+import { candidateKeys } from '~~/utils/metadata/cached';
+
+/**
+ * POST /api/metadata/tint — la teinte de l'affiche, mise en cache avec la fiche.
+ *
+ * La fiche d'un torrent calcule déjà la couleur dominante de son affiche (un
+ * canevas de 12×18 côté navigateur) et la pose sur son bandeau. Le catalogue
+ * veut la même couleur sur le filet des cartes d'œuvres, sans refaire vingt
+ * fois ce calcul ni vingt fois l'image : la fiche la dépose ici, le cache la
+ * garde trente jours, `worksFromCache` la lit avec le titre et l'affiche.
+ *
+ * Trois entiers 0-255, rien d'autre : ce que le navigateur envoie n'est pas
+ * une couleur qu'on injecte, c'est trois nombres qu'on revalide.
+ */
+const bodySchema = z.object({
+  // Les trois sources qui ont une fiche en cache ; IMDb et TVDB se résolvent en TMDb avant.
+  source: z.enum(['tmdb', 'igdb', 'openlibrary']),
+  id: z.string().trim().min(1).max(128),
+  tint: z.string().regex(/^\d{1,3} \d{1,3} \d{1,3}$/),
+});
+const TINT_TTL_S = 30 * 86400;
+/** La forme d'un identifiant par source : rien d'autre ne devient une clé Redis. */
+const ID_SHAPE: Record<string, RegExp> = {
+  // Nu ou préfixé : les releases portent l'un ou l'autre, `candidateKeys` sait les deux.
+  tmdb: /^((movie|tv)\/)?\d{1,10}$/,
+  igdb: /^\d{1,10}$/,
+  openlibrary: /^OL\d{1,10}[WM]$/,
+};
+
+export const tintCacheKey = (source: string, id: string) => `meta:v1:tint:${source}:${id}`;
+
+export default defineEventHandler(async (event) => {
+  const { user } = await requireUserSession(event);
+  await rateLimit(event, RATE_LIMITS.public);
+  const body = await validateBody(event, bodySchema);
+  const channels = body.tint.split(' ').map(Number);
+  if (channels.some((c) => !Number.isInteger(c) || c < 0 || c > 255)) {
+    throw createError({ statusCode: 400, message: 'tint: each channel must be 0-255' });
+  }
+  if (!ID_SHAPE[body.source]?.test(body.id)) {
+    throw createError({ statusCode: 400, message: 'id: not an identifier of this source' });
+  }
+  // Seulement une œuvre que le cache connaît déjà : la fiche l'a cherchée avant
+  // d'en calculer la couleur. Sans cela, chaque membre pouvait semer des clés à
+  // volonté. La réponse ne dit PAS si l'œuvre était connue : un 404 ici
+  // répondait « cette instance a-t-elle cette œuvre ? » à qui la demandait.
+  const me = await db.query.users.findFirst({ where: eq(schema.users.id, user.id), columns: { language: true } });
+  const known = await redis.exists(...candidateKeys({ source: body.source, id: body.id }, me?.language ?? undefined));
+  if (known) await redis.set(tintCacheKey(body.source, body.id), channels.join(' '), 'EX', TINT_TTL_S);
+  return { ok: true };
+});
diff --git a/apps/api/routes/api/torrents/[hash].get.ts b/apps/api/routes/api/torrents/[hash].get.ts
index f58bbc27..9475688f 100644
--- a/apps/api/routes/api/torrents/[hash].get.ts
+++ b/apps/api/routes/api/torrents/[hash].get.ts
@@ -1,8 +1,9 @@
 import { db, schema } from '@trackarr/db';
-import { and, eq } from 'drizzle-orm';
+import { and, count, eq } from 'drizzle-orm';
 import { getPeers, getStats } from '~~/utils/server';
 import { redactUploader } from '~~/utils/uploaderVisibility';
 import { validateParam, infoHashSchema } from '~~/utils/schemas';
+import { COMMENTS_PAGE_SIZE } from './[hash]/comments.get';
 
 export default defineEventHandler(async (event) => {
   const { user: session } = await requireUserSession(event);
@@ -37,6 +38,10 @@ export default defineEventHandler(async (event) => {
           },
         },
         orderBy: (c, { desc }) => [desc(c.createdAt)],
+        // La première page seulement : un fil de trois cents commentaires
+        // partait en entier dans la charge utile de CHAQUE visite. La suite
+        // se demande à `GET /api/torrents/:hash/comments`.
+        limit: COMMENTS_PAGE_SIZE,
       },
     },
   });
@@ -90,7 +95,7 @@ export default defineEventHandler(async (event) => {
     }
   }
 
-  const [stats, peers, favorite] = await Promise.all([
+  const [stats, peers, favorite, commentCount] = await Promise.all([
     getStats(infoHash),
     getPeers(infoHash),
     // Cheap "did this viewer star this torrent?" lookup — hits
@@ -104,6 +109,12 @@ export default defineEventHandler(async (event) => {
       ),
       columns: { userId: true },
     }),
+    // Le fil entier ne descend plus : son compte, si — le sommaire l'annonce.
+    db
+      .select({ n: count() })
+      .from(schema.torrentComments)
+      .where(eq(schema.torrentComments.torrentId, torrent.id))
+      .then((r) => Number(r[0]?.n ?? 0)),
   ]);
 
   const tags = torrent.torrentTags?.map((tt) => tt.tag) || [];
@@ -121,6 +132,7 @@ export default defineEventHandler(async (event) => {
     ...torrent,
     ...uploaderView,
     tags,
+    commentCount,
     torrentTags: undefined,
     stats: {
       seeders: stats.seeders,
diff --git a/apps/api/routes/api/torrents/[hash]/comments.get.ts b/apps/api/routes/api/torrents/[hash]/comments.get.ts
new file mode 100644
index 00000000..a438deba
--- /dev/null
+++ b/apps/api/routes/api/torrents/[hash]/comments.get.ts
@@ -0,0 +1,64 @@
+import { and, desc, eq, lt, sql } from 'drizzle-orm';
+import { z } from 'zod';
+import { db, schema } from '@trackarr/db';
+import { requireAuthSession } from '~~/utils/adminAuth';
+import { validateParam, validateQuery, infoHashSchema } from '~~/utils/schemas';
+import { assertVisibleTorrent } from '~~/utils/torrentListing';
+import { rateLimit, RATE_LIMITS } from '~~/utils/rateLimit';
+
+/**
+ * GET /api/torrents/:hash/comments — le fil, par pages.
+ *
+ * La fiche embarque la première page ; celle-ci sert les suivantes. Pagination
+ * par CURSEUR (`before`, la date du plus ancien déjà affiché) et non par
+ * décalage : un commentaire publié entre deux clics décale une pagination par
+ * `OFFSET` et fait sauter une ligne ou la répéter. Un curseur ne bouge pas.
+ *
+ * Même visibilité que la fiche : un torrent en attente, retiré ou adulte
+ * masqué répond 404 plutôt que d'ouvrir son fil.
+ */
+export const COMMENTS_PAGE_SIZE = 20;
+
+const querySchema = z.object({
+  before: z.string().datetime().optional(),
+  /** L'identifiant de la ligne du curseur : deux commentaires peuvent partager une date. */
+  beforeId: z.string().min(1).max(64).optional(),
+  limit: z.coerce.number().int().min(1).max(50).default(COMMENTS_PAGE_SIZE),
+});
+
+export default defineEventHandler(async (event) => {
+  const session = await requireAuthSession(event);
+  await rateLimit(event, RATE_LIMITS.public);
+  const hash = validateParam(event, 'hash', infoHashSchema).toLowerCase();
+  const { before, beforeId, limit } = validateQuery(event, querySchema);
+  const torrent = await assertVisibleTorrent(hash, session.user);
+
+  /*
+   * Le curseur porte la date ET l'identifiant, comparés en couple.
+   *
+   * Sur la seule date, deux commentaires écrits dans la même transaction (un
+   * import partage un `now()`) rendaient la page suivante vide pour toujours,
+   * ou faisaient sauter la ligne frontière. `::timestamp` plutôt qu'un `Date` :
+   * la colonne est sans fuseau, et le texte revient tel que l'API l'a émis.
+   */
+  const cursor =
+    before && beforeId
+      ? sql`(${schema.torrentComments.createdAt}, ${schema.torrentComments.id}) < (${before}::timestamp, ${beforeId})`
+      : before
+        ? lt(schema.torrentComments.createdAt, sql`${before}::timestamp`)
+        : undefined;
+
+  // Une ligne de plus que demandé : sa présence dit qu'il en reste, sans un
+  // `count(*)` sur tout le fil à chaque page.
+  const rows = await db.query.torrentComments.findMany({
+    where: cursor
+      ? and(eq(schema.torrentComments.torrentId, torrent.id), cursor)
+      : eq(schema.torrentComments.torrentId, torrent.id),
+    orderBy: [desc(schema.torrentComments.createdAt), desc(schema.torrentComments.id)],
+    limit: limit + 1,
+    columns: { id: true, content: true, createdAt: true },
+    with: { author: { columns: { id: true, username: true } } },
+  });
+
+  return { items: rows.slice(0, limit), more: rows.length > limit };
+});
diff --git a/apps/api/routes/api/torrents/[hash]/my-obligation.get.ts b/apps/api/routes/api/torrents/[hash]/my-obligation.get.ts
new file mode 100644
index 00000000..abf75e88
--- /dev/null
+++ b/apps/api/routes/api/torrents/[hash]/my-obligation.get.ts
@@ -0,0 +1,89 @@
+/**
+ * GET /api/torrents/:hash/my-obligation
+ *
+ * Ce que le membre connecté doit encore À CE TORRENT, pour que sa page le dise.
+ *
+ * `hnr_tracking` porte, par couple (membre, torrent), le temps de seed effectué,
+ * le temps exigé, l'état de défaut et l'exemption. Rien de tout cela n'atteignait
+ * la page de détail : un membre ne pouvait pas savoir, en regardant le torrent
+ * qu'il vient de télécharger, s'il lui devait encore des heures — l'information
+ * n'existait que dans la liste de ses téléchargements, une page plus loin.
+ *
+ * Renvoie `null`, et non un 404, quand il n'y a pas de ligne : « ce membre n'a
+ * jamais téléchargé ce torrent » est une réponse, pas une erreur, et le front
+ * doit pouvoir masquer la carte sans traiter un cas d'échec.
+ *
+ * Route à part plutôt qu'un champ du détail, pour deux raisons : la charge du
+ * détail est mise en cache et partagée entre membres, alors que cette réponse
+ * est propre à un membre ; et la page la charge en `lazy`, donc elle ne retarde
+ * pas le premier octet.
+ */
+import { and, eq } from 'drizzle-orm';
+import { db, schema } from '@trackarr/db';
+import { requireAuthSession } from '~~/utils/adminAuth';
+import { validateParam, infoHashSchema } from '~~/utils/schemas';
+import { isHnrEnabled, getHnrRequiredSeedTime } from '~~/utils/settings';
+import { assertVisibleTorrent } from '~~/utils/torrentListing';
+
+export default defineEventHandler(async (event) => {
+  const session = await requireAuthSession(event);
+  const hash = validateParam(event, 'hash', infoHashSchema);
+
+  // Visible pour ce membre, sinon 404 : la route ne doit pas confirmer un hash
+  // en attente ou retiré que la fiche lui refuse.
+  const torrent = await assertVisibleTorrent(hash.toLowerCase(), session.user);
+
+  const [row] = await db
+    .select({
+      seedTime: schema.hnrTracking.seedTime,
+      requiredSeedTime: schema.hnrTracking.requiredSeedTime,
+      isHnr: schema.hnrTracking.isHnr,
+      isExempt: schema.hnrTracking.isExempt,
+      completedAt: schema.hnrTracking.completedAt,
+      downloaded: schema.hnrTracking.downloaded,
+    })
+    .from(schema.hnrTracking)
+    .where(
+      and(
+        eq(schema.hnrTracking.userId, session.user.id),
+        eq(schema.hnrTracking.torrentId, torrent.id),
+      ),
+    )
+    .limit(1);
+
+  /*
+   * Pas encore de ligne : le membre n'a jamais pris cette release. S'il la
+   * prend, c'est le seuil GLOBAL du moment qui sera figé sur sa ligne — donc
+   * c'est lui qu'on annonce, sous la forme d'une obligation « pas encore
+   * prise ». Avant, la carte ne disait rien tant qu'on n'avait pas cliqué :
+   * l'engagement se découvrait après coup. Hit & Run désactivé → `null`, il
+   * n'y a rien à annoncer.
+   */
+  if (!row) {
+    if (!(await isHnrEnabled())) return null;
+    return {
+      downloaded: false,
+      seedTime: 0,
+      requiredSeedTime: await getHnrRequiredSeedTime(),
+      isHnr: false,
+      isExempt: false,
+      completedAt: null,
+    };
+  }
+
+  return {
+    /*
+     * `downloaded > 0` et non « la ligne existe » : l'API pose une ligne dès le
+     * clic sur le fichier .torrent, pour que la page des téléchargements montre
+     * la release avant le premier octet. Une ligne à zéro octet signifie donc
+     * « récupéré, jamais commencé » — et afficher une obligation de seed à
+     * quelqu'un qui n'a rien téléchargé serait faux.
+     */
+    downloaded: row.downloaded > 0,
+    seedTime: row.seedTime,
+    requiredSeedTime: row.requiredSeedTime,
+    isHnr: row.isHnr,
+    isExempt: row.isExempt,
+    completedAt: row.completedAt ? row.completedAt.toISOString() : null,
+  };
+});
diff --git a/apps/api/routes/api/torrents/[hash]/stats-history.get.ts b/apps/api/routes/api/torrents/[hash]/stats-history.get.ts
new file mode 100644
index 00000000..4706d5cc
--- /dev/null
+++ b/apps/api/routes/api/torrents/[hash]/stats-history.get.ts
@@ -0,0 +1,57 @@
+import { and, desc, eq, gte, sql } from 'drizzle-orm';
+import { db, schema } from '@trackarr/db';
+import { requireAuthSession } from '~~/utils/adminAuth';
+import { validateParam, infoHashSchema } from '~~/utils/schemas';
+import { assertVisibleTorrent } from '~~/utils/torrentListing';
+
+/**
+ * Les sept derniers points de l'essaim d'un torrent — un par jour.
+ *
+ * La fiche trace ces points en courbe à côté du bouton de téléchargement et y
+ * ajoute elle-même la valeur du moment (celle de `torrent_stats`, qu'elle a
+ * déjà) comme dernier point. Sept jours parce que c'est la fenêtre qui répond
+ * à la question posée — « ça meurt ou ça revit ? » — sans que la courbe
+ * devienne un graphique à lire.
+ *
+ * Les jours SANS point ne sont pas comblés ici : un jour absent veut dire que
+ * le collecteur n'a pas tourné (ou que la table vient d'être créée), pas que
+ * l'essaim était vide, et le client peut le dire au lieu de dessiner un zéro.
+ *
+ * Réservée aux membres, comme le reste de la fiche : le nombre de sources est
+ * une information de l'instance, pas une page publique.
+ */
+export default defineEventHandler(async (event) => {
+  const session = await requireAuthSession(event);
+  const hash = validateParam(event, 'hash', infoHashSchema).toLowerCase();
+  // La même visibilité que le listing : un hash en attente, retiré ou adulte
+  // masqué répond 404, pas un historique — sinon la route dit qu'il existe.
+  await assertVisibleTorrent(hash, session.user);
+
+  const rows = await db
+    .select({
+      day: schema.torrentStatsHistory.day,
+      seeders: schema.torrentStatsHistory.seeders,
+      leechers: schema.torrentStatsHistory.leechers,
+    })
+    .from(schema.torrentStatsHistory)
+    .where(
+      and(
+        eq(schema.torrentStatsHistory.infoHash, hash),
+        gte(schema.torrentStatsHistory.day, sql`current_date - 7`),
+      ),
+    )
+    .orderBy(desc(schema.torrentStatsHistory.day))
+    .limit(8);
+
+  // Du plus ancien au plus récent : c'est l'ordre d'une courbe.
+  return {
+    days: 7,
+    points: rows.reverse().map((r) => ({
+      // `date` arrive en chaîne ISO du jour (`YYYY-MM-DD`) : le pilote ne la
+      // convertit pas en `Date`, donc pas de fuseau à démêler.
+      day: String(r.day),
+      seeders: r.seeders,
+      leechers: r.leechers,
+    })),
+  };
+});
diff --git a/apps/api/routes/api/torrents/facets.get.ts b/apps/api/routes/api/torrents/facets.get.ts
new file mode 100644
index 00000000..6327577a
--- /dev/null
+++ b/apps/api/routes/api/torrents/facets.get.ts
@@ -0,0 +1,308 @@
+import { createHash } from 'node:crypto';
+import { db, schema } from '@trackarr/db';
+import { and, desc, eq, sql, type SQL } from 'drizzle-orm';
+import { redis } from '~~/utils/server';
+import { validateQuery, torrentQuerySchema } from '~~/utils/schemas';
+import { rateLimit, RATE_LIMITS } from '~~/utils/rateLimit';
+import {
+  filterConditions,
+  searchConditions,
+  tagGroupsCondition,
+  visibilityConditions,
+  YEAR_IN_NAME_RE,
+  type ListingFilters,
+} from '~~/utils/torrentListing';
+
+/**
+ * GET /api/torrents/facets — ce qui existe dans la recherche courante.
+ *
+ * Le rail du catalogue affiche, à côté de chaque valeur, le nombre de releases
+ * qu'elle donnerait : on voit ce qui existe AVANT de filtrer, au lieu de
+ * découvrir une liste vide. Les comptes suivent la règle des facettes : pour
+ * une dimension, tous les autres filtres s'appliquent, le sien non — sinon la
+ * catégorie cochée serait la seule à compter, et on ne pourrait plus changer.
+ *
+ * Quatre lectures : catégories, étiquettes, années, options. Les étiquettes
+ * ne sont pas rangées par famille ici — c'est le vocabulaire de la barre
+ * (`searchTokens.ts`) qui sait qu'un `x265` est un codec ; l'API rend des
+ * slugs et des comptes, rien de plus.
+ */
+const MAX_TAGS = 80;
+/*
+ * Vingt secondes de cache par membre et par requête : la route fait une
+ * demi-douzaine de lectures, et un membre qui coche trois facettes de suite
+ * les redemande à l'identique entre deux. Le membre est dans la clé — les
+ * comptes « pas encore pris » et « favoris » lui appartiennent.
+ */
+const CACHE_TTL_S = 20;
+
+export default defineEventHandler(async (event) => {
+  const { user } = await requireUserSession(event);
+  // Une requête de facettes, c'est une dizaine de comptes, et jusqu'à cinquante
+  // quand rien ne sort (un par critère retiré, un par famille d'étiquettes).
+  // La même limite que la vue Œuvres, sinon un seul membre occupe le pool.
+  await rateLimit(event, RATE_LIMITS.public);
+  const query = validateQuery(event, torrentQuerySchema);
+  const viewer = { id: user.id, isAdmin: !!user.isAdmin, isModerator: !!user.isModerator };
+
+  const cacheKey = `facets:v2:${user.id}:${createHash('sha1')
+    .update(
+      JSON.stringify(
+        Object.entries(query)
+          .filter(([k, v]) => v !== undefined && !['page', 'limit', 'sortBy', 'order'].includes(k))
+          .sort(([a], [b]) => (a < b ? -1 : 1)),
+      ),
+    )
+    .digest('hex')}`;
+  const cached = await redis.get(cacheKey).catch(() => null);
+  if (cached) return JSON.parse(cached);
+
+  const base: SQL[] = await visibilityConditions(viewer);
+  const { primary, fuzzy } = await searchConditions(query.search);
+  // Le listing se replie sur la recherche approximative quand l'exacte ne rend
+  // rien ; les facettes doivent compter la même chose que ce qu'il montre.
+  let search = primary;
+  if (primary && fuzzy) {
+    const all = await filterConditions(query, viewer);
+    const [row] = await db
+      .select({ n: sql<number>`count(*)::int` })
+      .from(schema.torrents)
+      .where(and(...base, ...all, primary));
+    if ((row?.n ?? 0) === 0) search = fuzzy;
+  }
+  const withBase = (extra: SQL[]) => and(...base, ...(search ? [search] : []), ...extra);
+  const without = (drop: Array<keyof ListingFilters>) => {
+    const q: ListingFilters = { ...query };
+    for (const k of drop) delete q[k];
+    return filterConditions(q, viewer);
+  };
+
+  /*
+   * Les étiquettes : `tagGroups` porte un groupe par famille (« hevc,x265 »
+   * pour le codec, « vostfr » pour la langue). Pour compter la famille du
+   * groupe i, on applique tous les groupes SAUF le i-ème — l'API ne sait pas
+   * quelle famille est laquelle, mais la page le sait : elle a construit la
+   * chaîne, elle lit `tagsByGroup[i]` pour la famille i et `tags` pour les
+   * autres.
+   */
+  const groups = (query.tagGroups ?? '').split(';').filter((g) => g.trim());
+  const tagCounts = async (drop: number | null) => {
+    const c = await without(['tagGroups']);
+    const kept = groups.filter((_, i) => i !== drop).join(';');
+    const cond = kept ? tagGroupsCondition(kept) : null;
+    return db
+      .select({
+        slug: schema.tags.slug,
+        name: schema.tags.name,
+        count: sql<number>`count(DISTINCT ${schema.torrents.id})::int`,
+      })
+      .from(schema.torrents)
+      .innerJoin(schema.torrentTags, eq(schema.torrentTags.torrentId, schema.torrents.id))
+      .innerJoin(schema.tags, eq(schema.tags.id, schema.torrentTags.tagId))
+      .where(withBase(cond ? [...c, cond] : c))
+      .groupBy(schema.tags.slug, schema.tags.name)
+      .orderBy(desc(sql`count(DISTINCT ${schema.torrents.id})`), schema.tags.slug)
+      .limit(MAX_TAGS);
+  };
+  const tagsByGroupList = await Promise.all(groups.map((_, i) => tagCounts(i)));
+  const tagsByGroup: Record<number, Awaited<ReturnType<typeof tagCounts>>> = {};
+  tagsByGroupList.forEach((rows, i) => {
+    tagsByGroup[i] = rows;
+  });
+
+  const count = async (extra: SQL[]) => {
+    const [row] = await db.select({ n: sql<number>`count(*)::int` }).from(schema.torrents).where(withBase(extra));
+    return row?.n ?? 0;
+  };
+  /*
+   * Ce que le listing AFFICHERAIT pour ces critères : la recherche exacte, et
+   * la recherche approximative seulement si l'exacte ne rend rien — la même
+   * règle que lui. Une suggestion « sans 480p : 9 » qui ouvre une page à 1
+   * résultat est pire que pas de suggestion.
+   */
+  const countLikeListing = async (extra: SQL[]) => {
+    if (!primary) return count(extra);
+    const [exact] = await db
+      .select({ n: sql<number>`count(*)::int` })
+      .from(schema.torrents)
+      .where(and(...base, primary, ...extra));
+    if ((exact?.n ?? 0) > 0 || !fuzzy) return exact?.n ?? 0;
+    const [approx] = await db
+      .select({ n: sql<number>`count(*)::int` })
+      .from(schema.torrents)
+      .where(and(...base, fuzzy, ...extra));
+    return approx?.n ?? 0;
+  };
+  const strictConditions = await filterConditions(query, viewer);
+  const [total, statsRow] = await Promise.all([
+    count(strictConditions),
+    // Le collecteur écrit `torrent_stats` par passes : c'est la date que la
+    // page affiche à côté de « avec des sources » et du tri par essaim.
+    // En ISO UTC explicite : une chaîne nue sans fuseau serait relue comme de
+    // l'heure locale par le navigateur — deux heures d'écart en France.
+    db.select({ at: sql<string | null>`to_char(max(updated_at), 'YYYY-MM-DD"T"HH24:MI:SS"Z"')` }).from(schema.torrentStats).then((r) => r[0]?.at ?? null),
+  ]);
+
+  /*
+   * Quand rien ne sort : ce que donnerait la même recherche SANS chacun de ses
+   * critères, un compte par critère posé, plus le catalogue entier. C'est
+   * l'état vide qui propose au lieu de conclure — et il ne coûte que quand il
+   * n'y a rien à afficher.
+   */
+  let dropOne: Array<{ key: string; count: number }> | null = null;
+  let catalogue: number | null = null;
+  if (total === 0) {
+    const keys: Array<keyof ListingFilters> = [
+      'categoryId', 'tag', 'imdbid', 'tmdbid', 'tvdbid', 'uploader', 'year', 'season', 'episode',
+      'minSeeders', 'freeleech', 'notTaken', 'hideSuperseded', 'favorites', 'since', 'groupKey',
+    ];
+    const present = keys.filter((k) => query[k] !== undefined && query[k] !== '');
+    const jobs: Array<Promise<{ key: string; count: number }>> = present.map(async (k) => ({
+      key: k,
+      count: await countLikeListing(await without([k])),
+    }));
+    for (let i = 0; i < groups.length; i++) {
+      jobs.push(
+        (async () => {
+          const c = await without(['tagGroups']);
+          const kept = groups.filter((_, j) => j !== i).join(';');
+          const cond = kept ? tagGroupsCondition(kept) : null;
+          return { key: `tagGroups:${i}`, count: await countLikeListing(cond ? [...c, cond] : c) };
+        })(),
+      );
+    }
+    if (query.search) {
+      jobs.push(
+        (async () => {
+          const [row] = await db
+            .select({ n: sql<number>`count(*)::int` })
+            .from(schema.torrents)
+            .where(and(...base, ...strictConditions));
+          return { key: 'search', count: row?.n ?? 0 };
+        })(),
+      );
+    }
+    const [drops, all] = await Promise.all([
+      Promise.all(jobs),
+      db.select({ n: sql<number>`count(*)::int` }).from(schema.torrents).where(and(...base)).then((r) => r[0]?.n ?? 0),
+    ]);
+    dropOne = drops.filter((d) => d.count > 0);
+    catalogue = all;
+  }
+  /*
+   * « Vouliez-vous dire » : les titres d'œuvres dont un MOT ressemble au
+   * texte (`word_similarity`, pas `similarity` : « friren » contre « Frieren:
+   * Beyond Journey's End » vaut 0,57 au mot et presque rien sur le titre
+   * entier — sous le seuil 0,6 de l'opérateur `<%`, d'où le seuil explicite à
+   * 0,45 ; la table est petite, le balayage l'est aussi). Seulement quand rien
+   * ne sort — sinon la liste parle d'elle-même.
+   */
+  let didYouMean: Array<{ source: string; externalId: string; title: string }> | null = null;
+  if (total === 0 && query.search && query.search.length >= 3) {
+    // Seulement des œuvres dont ce lecteur peut voir au moins une release :
+    // `work_titles` ne connaît ni la modération ni la préférence adulte, et un
+    // titre suggéré qui n'ouvre sur rien trahirait ce que le catalogue cache.
+    const visible = base.length ? sql`${and(...base)} AND` : sql``;
+    const rows = (await db.execute(sql`
+      SELECT source, external_id, title, word_similarity(${query.search}, title) AS sim
+        FROM ${schema.workTitles}
+       WHERE word_similarity(${query.search}, title) >= 0.45
+         AND EXISTS (
+           SELECT 1 FROM torrents
+            WHERE ${visible} (
+                  (work_titles.source = 'tmdb' AND (torrents.tmdb_id = work_titles.external_id OR torrents.tmdb_id = work_titles.bare_id))
+               OR (work_titles.source = 'igdb' AND torrents.igdb_id = work_titles.external_id)
+               OR (work_titles.source = 'openlibrary' AND torrents.openlibrary_id = work_titles.external_id)
+            )
+         )
+       ORDER BY sim DESC, title
+       LIMIT 8
+    `)) as unknown as Array<{ source: string; external_id: string; title: string; sim: number }>;
+    const seen = new Set<string>();
+    didYouMean = [];
+    for (const r of rows) {
+      const k = `${r.source}:${r.external_id}`;
+      if (seen.has(k)) continue;
+      seen.add(k);
+      didYouMean.push({ source: r.source, externalId: r.external_id, title: r.title });
+      if (didYouMean.length >= 3) break;
+    }
+  }
+
+  const [categories, tags, years, options] = await Promise.all([
+    without(['categoryId']).then((c) =>
+      db
+        .select({ id: schema.torrents.categoryId, count: sql<number>`count(*)::int` })
+        .from(schema.torrents)
+        .where(withBase(c))
+        .groupBy(schema.torrents.categoryId),
+    ),
+    tagCounts(null),
+    without(['year']).then(async (c) => {
+      /*
+       * Pas de colonne « année » : c'est le nom qui la porte, avec le MÊME
+       * motif que le filtre (`YEAR_IN_NAME_RE`).
+       *
+       * `regexp_matches(..., 'g')` et non `substring` : un nom peut porter deux
+       * années (« Show.1999.2001.remux »), et `substring` n'en rendait que la
+       * PREMIÈRE — le lot « 2001 » annonçait alors moins de releases qu'un clic
+       * sur 2001 n'en montrait.
+       */
+      // `withBase` peut ne rien rendre (un opérateur sans filtre ni voile) :
+      // sans le repli, la requête devenait `WHERE GROUP BY` et cassait.
+      const where = withBase(c) ?? sql`true`;
+      const rows = (await db.execute(sql`
+        SELECT (m.y)[1] AS year, count(DISTINCT torrents.id)::int AS count
+          FROM ${schema.torrents}
+          CROSS JOIN LATERAL regexp_matches(${schema.torrents.name}, ${YEAR_IN_NAME_RE}, 'g') AS m(y)
+         WHERE ${where}
+         GROUP BY 1
+         ORDER BY 1
+      `)) as unknown as Array<{ year: string | null; count: number }>;
+      return rows
+        .filter((r) => r.year !== null)
+        .map((r) => ({ year: Number(r.year), count: Number(r.count) }));
+    }),
+    without(['minSeeders', 'freeleech', 'notTaken', 'hideSuperseded', 'favorites', 'since']).then(async (c) => {
+      // Dans une liste SELECT, drizzle rend une colonne SANS sa table
+      // (`"info_hash"`) : à l'intérieur d'une sous-requête corrélée, ce nom
+      // désigne alors la colonne de la sous-requête, et Postgres répond « more
+      // than one row ». D'où les identifiants qualifiés à la main.
+      const [row] = await db
+        .select({
+          total: sql<number>`count(*)::int`,
+          withSeeders: sql<number>`count(*) FILTER (WHERE COALESCE((SELECT s.seeders FROM torrent_stats s WHERE s.info_hash = torrents.info_hash), 0) > 0)::int`,
+          freeleech: sql<number>`count(*) FILTER (WHERE torrents.download_multiplier = 0 AND (torrents.multipliers_until IS NULL OR torrents.multipliers_until > now()))::int`,
+          notTaken: sql<number>`count(*) FILTER (WHERE NOT EXISTS (SELECT 1 FROM hnr_tracking h WHERE h.user_id = ${viewer.id} AND h.torrent_id = torrents.id AND h.downloaded > 0))::int`,
+          superseded: sql<number>`count(*) FILTER (WHERE torrents.superseded_by_id IS NOT NULL)::int`,
+          favorites: sql<number>`count(*) FILTER (WHERE EXISTS (SELECT 1 FROM torrent_favorites f WHERE f.user_id = ${viewer.id} AND f.torrent_id = torrents.id))::int`,
+          today: sql<number>`count(*) FILTER (WHERE torrents.created_at >= now() - interval '24 hours')::int`,
+        })
+        .from(schema.torrents)
+        .where(withBase(c));
+      return row ?? { total: 0, withSeeders: 0, freeleech: 0, notTaken: 0, superseded: 0, favorites: 0, today: 0 };
+    }),
+  ]);
+
+  const payload = {
+    total,
+    statsAt: statsRow,
+    dropOne,
+    catalogue,
+    didYouMean,
+    categories: categories.filter((c) => c.id !== null) as Array<{ id: string; count: number }>,
+    tags,
+    tagsByGroup,
+    years,
+    options: {
+      withSeeders: options.withSeeders,
+      freeleech: options.freeleech,
+      notTaken: options.notTaken,
+      superseded: options.superseded,
+      favorites: options.favorites,
+      today: options.today,
+    },
+  };
+  void redis.set(cacheKey, JSON.stringify(payload), 'EX', CACHE_TTL_S).catch(() => {});
+  return payload;
+});
diff --git a/apps/api/routes/api/torrents/groups.get.ts b/apps/api/routes/api/torrents/groups.get.ts
index 2d3d4933..0833e709 100644
--- a/apps/api/routes/api/torrents/groups.get.ts
+++ b/apps/api/routes/api/torrents/groups.get.ts
@@ -41,6 +41,9 @@ import { z } from 'zod';
 import { db, schema, ftsVector } from '@trackarr/db';
 import { requireAuthSession } from '~~/utils/adminAuth';
 import { rateLimit, RATE_LIMITS } from '~~/utils/rateLimit';
+import { tagFilterCondition } from '~~/utils/tags';
+import { filterConditions, searchConditions } from '~~/utils/torrentListing';
+import { worksFromCache, workRefKey, type WorkRef } from '~~/utils/metadata/cached';
 import {
   FTS_CONFIG,
   parseSearchFields,
@@ -48,7 +51,7 @@ import {
 } from '~~/utils/search';
 import { adultCategoryIds } from '~~/utils/adultContent';
 import { getSetting, SETTINGS_KEYS } from '~~/utils/server';
-import { GROUP_SCOPES } from '~~/utils/torrentGroups';
+import { GROUP_SCOPES, groupKeySql, groupMemberWhere, parseGroupKey, VISIBLE } from '~~/utils/torrentGroups';
 import { listMixedGroups } from '~~/utils/mixedGroups';
 import { getFederationConfig, isFederationLive } from '~~/utils/federation/config';
 import { hasActiveCataloguePeer } from '~~/utils/remoteGroups';
@@ -59,6 +62,34 @@ const querySchema = z.object({
   limit: z.coerce.number().int().min(1).max(50).default(25),
   search: z.string().trim().max(200).optional(),
   categoryId: z.string().uuid().optional(),
+  /**
+   * Les tags, comme dans le listing plat.
+   *
+   * Il manquait, et zod retire en silence ce qu'il ne déclare pas : une URL
+   * `?tag=2160p&v=grouped` rendait donc le catalogue ENTIER — des livres, de
+   * la musique, des 1080p — sans un message d'erreur ni une ligne de journal.
+   * Un filtre absent est pire qu'un filtre cassé : rien ne le signale.
+   */
+  tag: z.string().max(255).optional(),
+  // Ce que la barre du catalogue produit en plus (voir `torrentQuerySchema`) :
+  // absents ici, zod les retirerait en silence et la vue groupée mentirait.
+  tagGroups: z.string().max(400).optional(),
+  // Les identifiants externes aussi : choisir une œuvre dans les suggestions
+  // pose un `tmdbid`, et la vue Œuvres est celle par défaut — un filtre que
+  // cette route ne connaît pas est un filtre retiré en silence.
+  imdbid: z.string().trim().min(1).max(64).optional(),
+  tmdbid: z.string().trim().min(1).max(64).optional(),
+  tvdbid: z.string().trim().min(1).max(64).optional(),
+  uploader: z.string().trim().min(1).max(64).optional(),
+  year: z.coerce.number().int().min(1900).max(2100).optional(),
+  season: z.coerce.number().int().min(0).max(999).optional(),
+  episode: z.coerce.number().int().min(0).max(9999).optional(),
+  minSeeders: z.coerce.number().int().min(0).max(100000).optional(),
+  freeleech: z.enum(['1', 'true']).optional(),
+  notTaken: z.enum(['1', 'true']).optional(),
+  hideSuperseded: z.enum(['1', 'true']).optional(),
+  favorites: z.enum(['1', 'true']).optional(),
+  since: z.enum(['24h', '7d', '30d']).optional(),
   // The filter the flat listing cannot express: "show me the season packs" is
   // a question about how a release is cut, not about what it contains.
   scope: z.enum(GROUP_SCOPES as unknown as [string, ...string[]]).optional(),
@@ -84,7 +115,7 @@ export default defineEventHandler(async (event) => {
   // next page rather than at the next login.
   const me = await db.query.users.findFirst({
     where: eq(schema.users.id, user.id),
-    columns: { showAdultContent: true },
+    columns: { showAdultContent: true, language: true },
   });
   if (!me?.showAdultContent) {
     const adultIds = await adultCategoryIds();
@@ -144,27 +175,56 @@ export default defineEventHandler(async (event) => {
 
   // Search folds into the group filter: a group matches when ANY of its
   // releases matches, which is what `WHERE` before `GROUP BY` gives for free.
+  // Tags — même prédicat que le listing plat, importé et non recopié.
+  //
+  // Le MIROIR est écarté dès qu'un tag est demandé. `remote_torrents` porte
+  // bien une colonne `tags`, mais en `jsonb` et dans un vocabulaire qui n'est
+  // pas le nôtre : les slugs viennent de l'instance d'en face. Je n'ai pas pu
+  // en observer la forme — la table est vide sur cette pile et rien dans le
+  // code d'ingestion ne la fixe — et écrire un prédicat `jsonb` à l'aveugle
+  // referait exactement le défaut qu'on corrige : des lignes qui traversent un
+  // filtre sans être évaluées. Mieux vaut un miroir absent qu'un miroir non
+  // filtré. Le listing plat, lui, ne fédère pas du tout : le comportement des
+  // deux vues se rejoint donc quand on filtre par tag.
+  if (query.tag) {
+    const cond = await tagFilterCondition(query.tag);
+    if (cond) {
+      conditions.push(cond);
+      remote.push(sql`false`);
+    }
+  }
+  // Les filtres de la barre : même prédicats que le listing plat, importés. Le
+  // miroir n'a ni tags dans notre vocabulaire, ni suivi de seed, ni uploadeur
+  // à nous : dès qu'un de ces filtres est posé, il est écarté.
+  {
+    const { tag: _tag, categoryId: _cat, ...barFilters } = query as Record<string, unknown>;
+    const extra = await filterConditions(barFilters as Parameters<typeof filterConditions>[0], {
+      id: user.id,
+      isAdmin: !!user.isAdmin,
+      isModerator: !!user.isModerator,
+    });
+    if (extra.length) {
+      conditions.push(...extra);
+      remote.push(sql`false`);
+    }
+  }
+
   if (query.search) {
-    const tsq = toPrefixTsQuery(query.search);
-    if (tsq) {
-      const fields = parseSearchFields(
-        await getSetting(SETTINGS_KEYS.SEARCH_FIELDS),
-      );
-      const q = sql`to_tsquery(${FTS_CONFIG}, ${tsq})`;
-      const branches: SQL[] = [];
-      if (fields.includes('name')) {
-        branches.push(sql`${ftsVector(schema.torrents.name)} @@ ${q}`);
-      }
-      if (fields.includes('description')) {
-        branches.push(sql`${ftsVector(schema.torrents.description)} @@ ${q}`);
-      }
-      if (fields.includes('nfo')) {
-        branches.push(sql`${ftsVector(schema.torrents.nfo)} @@ ${q}`);
+    // Les mêmes prédicats que le listing et les facettes (`searchConditions`) :
+    // titres d'œuvres, étiquettes, et le repli approximatif quand l'exact ne
+    // rend rien. Sinon la bande disait « 9 releases · 0 œuvre » dès que le nom
+    // du fichier ne contenait pas le titre.
+    const { primary, fuzzy } = await searchConditions(query.search);
+    if (primary) {
+      let search = primary;
+      if (fuzzy) {
+        const [row] = await db
+          .select({ n: sql<number>`count(*)::int` })
+          .from(schema.torrents)
+          .where(and(...conditions, VISIBLE, primary));
+        if ((row?.n ?? 0) === 0) search = fuzzy;
       }
-      conditions.push(branches.length ? or(...branches)! : sql`false`);
-    } else {
-      // Nothing usable survived the scrub — return the unfiltered page rather
-      // than an empty one, same as the flat listing.
+      conditions.push(search);
     }
     // The mirror has no tsvector, and building one would mean an index over
     // data we did not author and may drop wholesale when a partner is removed.
@@ -193,12 +253,54 @@ export default defineEventHandler(async (event) => {
     remoteWhere: remote.length ? and(...remote) : undefined,
     localOnly,
     scope: query.scope as never,
-    sortBy: query.sortBy,
+    // Pas de rang plein texte pour un groupe : la pertinence y vaut nouveauté.
+    sortBy: query.sortBy === 'relevance' ? 'age' : query.sortBy,
     order: query.order,
   });
 
+  /*
+   * Ce que la carte d'une œuvre montre sans ouvrir : le titre, l'année et
+   * l'affiche tels que le cache des métadonnées les connaît (jamais l'amont
+   * depuis ici — voir `metadata/cached.ts`), et les étiquettes de ses releases
+   * locales, dont la page tire l'échelle des qualités. Deux lectures pour la
+   * page, quel que soit le nombre de groupes.
+   */
+  const refs = groups
+    .filter((gr) => gr.source !== 'solo')
+    .map((gr) => ({ source: gr.source as WorkRef['source'], id: gr.externalId }));
+  // La langue vient de la ligne du membre, déjà lue plus haut : la session
+  // d'administration ne la porte pas.
+  const language = me?.language ?? undefined;
+  const [works, slugRows] = await Promise.all([
+    worksFromCache(refs, language),
+    groups.length
+      ? ((await db.execute(sql`
+          SELECT ${groupKeySql} AS gkey, tg.slug AS slug, count(*)::int AS n
+            FROM ${schema.torrents}
+            JOIN ${schema.torrentTags} tt ON tt.torrent_id = ${schema.torrents.id}
+            JOIN ${schema.tags} tg ON tg.id = tt.tag_id
+           WHERE ${conditions.length ? and(...conditions)! : sql`true`}
+             AND ${VISIBLE}
+             AND (${or(...groups.map((gr) => groupMemberWhere(parseGroupKey(gr.key))))!})
+           GROUP BY 1, 2
+           ORDER BY 1, 3 DESC, 2
+        `)) as unknown as Array<{ gkey: string; slug: string; n: number }>)
+      : [],
+  ]);
+  const slugsByKey = new Map<string, string[]>();
+  for (const r of slugRows) {
+    const list = slugsByKey.get(r.gkey) ?? [];
+    list.push(r.slug);
+    slugsByKey.set(r.gkey, list);
+  }
+  const enriched = groups.map((gr) => ({
+    ...gr,
+    work: gr.source === 'solo' ? null : works.get(workRefKey({ source: gr.source as WorkRef['source'], id: gr.externalId })) ?? null,
+    tagSlugs: slugsByKey.get(gr.key) ?? [],
+  }));
+
   return {
-    groups,
+    groups: enriched,
     merged: !localOnly,
     pagination: {
       page: query.page,
diff --git a/apps/api/routes/api/torrents/index.get.ts b/apps/api/routes/api/torrents/index.get.ts
index 68120044..7fb58610 100644
--- a/apps/api/routes/api/torrents/index.get.ts
+++ b/apps/api/routes/api/torrents/index.get.ts
@@ -1,307 +1,82 @@
 import { db, schema } from '@trackarr/db';
 import { buildTorrentOrderBy } from '~~/utils/torrentSort';
-import { getStats } from '~~/utils/server';
-import { eq, sql, and, or, inArray, notInArray, isNull, type SQL } from 'drizzle-orm';
+import { eq, sql, and, type SQL } from 'drizzle-orm';
 import { validateQuery, torrentQuerySchema } from '~~/utils/schemas';
-import { slugifyTag } from '~~/utils/tags';
-import { normalizeMediaId, tmdbIdBare } from '~~/utils/mediaIds';
-import { getSetting } from '~~/utils/settings';
 import {
-  FTS_CONFIG,
-  SEARCH_FIELDS_SETTING,
-  SEARCH_FUZZY_SETTING,
-  ftsVector,
-  fuzzyTerm,
-  parseSearchFields,
-  parseSearchFuzzy,
-  toPrefixTsQuery,
-} from '~~/utils/search';
-import { adultCategoryIds } from '~~/utils/adultContent';
+  enrichListing,
+  filterConditions,
+  searchConditions,
+  visibilityConditions,
+} from '~~/utils/torrentListing';
+import { recordSearchMiss } from '~~/utils/searchMisses';
+import { rateLimit, RATE_LIMITS } from '~~/utils/rateLimit';
 
 /**
- * How many pinned releases one listing may carry.
+ * GET /api/torrents — le listing plat.
  *
- * Small on purpose. A pin is an editorial act — "read this one" — and the
- * moment a first screen is all pins the listing has stopped being a listing.
- * An operator who wants ten things at the top wants a homepage block, not a
- * catalogue.
+ * Les prédicats vivent dans `utils/torrentListing.ts`, partagés avec la vue
+ * groupée et les comptes par facette : une route qui réécrit ses conditions
+ * finit par en oublier une, et rien ne le signale. Ce fichier ne garde que ce
+ * qui lui est propre — les épinglés en tête de première page, le repli
+ * approximatif quand la recherche exacte ne rend rien, la pagination.
+ *
+ * Chaque ligne porte, en plus de la table, ce que la page du catalogue montre :
+ * l'essaim vivant, favori et « déjà prise » pour ce membre, l'uploadeur, la
+ * gratuité du moment, et l'œuvre telle que le cache des métadonnées la connaît
+ * — sans jamais interroger un fournisseur depuis ici.
  */
 const MAX_PINNED = 5;
 
 export default defineEventHandler(async (event) => {
-  // Require authentication
   const { user } = await requireUserSession(event);
-
-  // Validate query parameters with Zod
+  await rateLimit(event, RATE_LIMITS.public);
   const query = validateQuery(event, torrentQuerySchema);
-
   const offset = (query.page - 1) * query.limit;
+  const viewer = {
+    id: user.id,
+    isAdmin: !!user.isAdmin,
+    isModerator: !!user.isModerator,
+    language: typeof user.language === 'string' ? user.language : null,
+  };
 
-  // Check if user can see unapproved torrents
-  const canSeeUnapproved = user.isAdmin || user.isModerator;
-
-  // Refresh the adult preference from the row — the session is updated
-  // lazily and we want the toggle to take effect on the very next page.
-  const me = await db.query.users.findFirst({
-    where: eq(schema.users.id, user.id),
-    columns: { showAdultContent: true },
-  });
-  const showAdult = me?.showAdultContent ?? false;
-
-  // Build where clause
-  const conditions: SQL[] = [];
-
-  // Only show accepted torrents to regular users (but show their own
-  // pending / changes_requested / rejected so they can find them in
-  // their own listings even though they're hidden from the public
-  // catalogue).
-  if (!canSeeUnapproved) {
-    conditions.push(
-      or(
-        eq(schema.torrents.moderationStatus, 'accepted'),
-        eq(schema.torrents.uploaderId, user.id)
-      )!
-    );
-  }
-
-  /*
-   * `is_active` est un interrupteur d'opérateur, et il ne coupait pas ici.
-   *
-   * `apps/tracker/db/queries/torrents.sql` le décrit comme tel et le tracker Go
-   * refuse d'annoncer une release inactive. Côté API il est honoré par RSS, par
-   * Torznab, par la fédération, par les groupes et par les statistiques — mais
-   * il était ABSENT du catalogue web, de la fiche et du téléchargement du
-   * `.torrent`, c'est-à-dire des trois seules surfaces qui comptent pour un
-   * retrait. Un opérateur qui basculait le drapeau à la main pour une demande
-   * DMCA voyait la release disparaître partout SAUF de l'endroit où on la
-   * trouve et de celui où on la récupère.
-   *
-   * Rien n'écrit `false` dans le code aujourd'hui, donc c'était inerte — un
-   * piège qui attendait la première fois qu'on s'en serve.
-   *
-   * Le personnel et le téléverseur continuent de voir la ligne : ils voient
-   * déjà les dépôts en attente, et retirer une release de la vue de celui qui
-   * doit la traiter n'aide personne.
-   */
-  if (!canSeeUnapproved) {
-    conditions.push(eq(schema.torrents.isActive, true));
-  }
-
-  // Hide adult-categorised torrents from users who haven't opted in.
-  // Uncategorised torrents (categoryId = null) are never adult so they
-  // pass through unconditionally.
-  if (!showAdult) {
-    const adultIds = await adultCategoryIds();
-    if (adultIds.length > 0) {
-      conditions.push(
-        or(
-          isNull(schema.torrents.categoryId),
-          notInArray(schema.torrents.categoryId, adultIds)
-        )!
-      );
-    }
-  }
-
-  // Free-text search. The infohash is handled upstream: it is an exact match
-  // served by a unique index and has no business in the text path. IMDb / TMDb
-  // / TVDB links never even reach here — the search bar detects them
-  // client-side and sends them as dedicated parameters (see below).
-  let searchCondition: SQL | null = null;
-  let fuzzyFallback: SQL | null = null;
-  if (query.search) {
-    const isHash = /^[0-9a-fA-F]{40}$/.test(query.search);
-    if (isHash) {
-      searchCondition = eq(schema.torrents.infoHash, query.search.toLowerCase());
-    } else {
-      const fields = parseSearchFields(await getSetting(SEARCH_FIELDS_SETTING));
-      const tsq = toPrefixTsQuery(query.search);
-      if (tsq && fields.length) {
-        const q = sql`to_tsquery(${FTS_CONFIG}, ${tsq})`;
-        const branches: SQL[] = [];
-        if (fields.includes('name')) {
-          branches.push(sql`${ftsVector(schema.torrents.name)} @@ ${q}`);
-        }
-        if (fields.includes('description')) {
-          branches.push(sql`${ftsVector(schema.torrents.description)} @@ ${q}`);
-        }
-        if (fields.includes('nfo')) {
-          branches.push(sql`${ftsVector(schema.torrents.nfo)} @@ ${q}`);
-        }
-        if (fields.includes('tags')) {
-          // A correlated EXISTS rather than a join: the join would duplicate
-          // rows for a torrent carrying several matching tags, and would need a
-          // DISTINCT that breaks pagination.
-          branches.push(sql`EXISTS (
-            SELECT 1 FROM ${schema.torrentTags} tt
-            JOIN ${schema.tags} tg ON tg.id = tt.tag_id
-            WHERE tt.torrent_id = ${schema.torrents.id}
-              AND ${ftsVector(sql`tg.name`)} @@ ${q}
-          )`);
-        }
-        searchCondition = branches.length > 1 ? or(...branches)! : branches[0]!;
-
-        // Typo fallback, prepared here but only executed when the full-text
-        // pass returns nothing: the trigram costs ten times more (237 ms
-        // against 23 ms over 200,000 rows), which is only justified in the face
-        // of an empty results page. `word_similarity`, not `similarity`: over a
-        // whole release name the global similarity stays below the threshold
-        // and never finds anything.
-        const fuzzy = fuzzyTerm(query.search);
-        if (fuzzy && parseSearchFuzzy(await getSetting(SEARCH_FUZZY_SETTING))) {
-          fuzzyFallback = sql`${fuzzy} <% ${schema.torrents.name}`;
-        }
-      } else if (tsq) {
-        // The operator disabled every field: text search returns nothing
-        // rather than returning everything.
-        searchCondition = sql`false`;
-      }
-    }
-  }
-  if (query.categoryId) {
-    // add category and subcategories filter
-    const subcategories = await db.query.categories.findMany({
-      where: eq(schema.categories.parentId, query.categoryId),
-      columns: { id: true },
-    });
-    conditions.push(
-      or(
-          eq(schema.torrents.categoryId, query.categoryId),
-          ...subcategories.map((subcat) => eq(schema.torrents.categoryId, subcat.id))
-      )!
-    );
-  }
-
-  // External media-id filters. Mirror the Torznab handler so a user
-  // pasting an IMDb URL into the search bar finds the same torrents
-  // Sonarr/Radarr would. Unparseable input → `WHERE false` rather
-  // than silently widening to "ignore the filter".
-  if (query.imdbid) {
-    const norm = normalizeMediaId('imdb', query.imdbid);
-    conditions.push(norm ? eq(schema.torrents.imdbId, norm) : sql`false`);
-  }
-  if (query.tmdbid) {
-    // Stored TMDb id may carry a `tv/` or `movie/` prefix; bare query
-    // values must still match. Same pattern as the Torznab handler.
-    const norm = normalizeMediaId('tmdb', query.tmdbid);
-    const bare = norm ? tmdbIdBare(norm) : null;
-    if (norm && bare) {
-      conditions.push(
-        or(
-          eq(schema.torrents.tmdbId, norm),
-          eq(schema.torrents.tmdbId, bare),
-          eq(schema.torrents.tmdbId, `movie/${bare}`),
-          eq(schema.torrents.tmdbId, `tv/${bare}`)
-        )!
-      );
-    } else {
-      conditions.push(sql`false`);
-    }
-  }
-  if (query.tvdbid) {
-    const norm = normalizeMediaId('tvdb', query.tvdbid);
-    conditions.push(norm ? eq(schema.torrents.tvdbId, norm) : sql`false`);
-  }
-
-  // Tag filter — `?tag=fhd,bluray` returns torrents that carry every tag in
-  // the list (AND semantics, matching how a user thinks: "show me torrents
-  // that are FHD AND Blu-Ray"). Resolves both names and slugs so the URL
-  // stays readable while the autocomplete can keep submitting whatever the
-  // user typed.
-  if (query.tag) {
-    const slugs = Array.from(
-      new Set(
-        query.tag
-          .split(',')
-          .map((s) => slugifyTag(s))
-          .filter(Boolean)
-      )
-    );
-    if (slugs.length > 0) {
-      const matchedTags = await db.query.tags.findMany({
-        where: inArray(schema.tags.slug, slugs),
-        columns: { id: true },
-      });
-      // If any requested slug doesn't exist, no torrent can carry it →
-      // honest empty result instead of widening to "ignore the filter".
-      if (matchedTags.length !== slugs.length) {
-        conditions.push(sql`false`);
-      } else {
-        const tagIds = matchedTags.map((t) => t.id);
-        // Sub-select: torrent_id matches every requested tag id. Use
-        // `count(distinct tag_id)` so the predicate stays correct
-        // regardless of any future de-normalisation in torrent_tags.
-        conditions.push(
-          inArray(
-            schema.torrents.id,
-            db
-              .select({ torrentId: schema.torrentTags.torrentId })
-              .from(schema.torrentTags)
-              .where(inArray(schema.torrentTags.tagId, tagIds))
-              .groupBy(schema.torrentTags.torrentId)
-              .having(
-                sql`count(distinct ${schema.torrentTags.tagId}) = ${tagIds.length}`
-              )
-          )
-        );
-      }
-    }
-  }
+  const conditions: SQL[] = [
+    ...(await visibilityConditions(viewer)),
+    ...(await filterConditions(query, viewer)),
+  ];
+  const { primary: searchCondition, fuzzy: fuzzyFallback, rankExact, rankFuzzy } = await searchConditions(query.search);
 
-  // The search predicate is kept apart from the filters, so the fuzzy fallback
-  // replays the same query replacing only that.
-  /**
-   * Pinned releases are lifted out of the flow entirely, on every page.
-   *
-   * Not folded into the ORDER BY, which is the obvious implementation and the
-   * wrong one: putting `is_sticky DESC` in front of the sort key stops every
-   * existing single-column index from serving it, so a catalogue that sorted by
-   * date off an index starts doing a full sort on every page. A separate,
-   * capped query costs one extra round trip on page 1 and nothing after.
-   *
-   * Excluded on every page rather than only on page 1 so a torrent appears
-   * exactly once in a listing, and so `total` and the page count agree with
-   * what the reader can actually scroll through.
-   */
   const notPinned = eq(schema.torrents.isSticky, false);
   const compose = (search: SQL | null) => {
     const all = search ? [...conditions, search, notPinned] : [...conditions, notPinned];
     return all.length > 0 ? and(...all) : undefined;
   };
   const countRows = async (where: SQL | undefined) => {
-    const [row] = await db
-      .select({ count: sql<number>`count(*)::int` })
-      .from(schema.torrents)
-      .where(where);
+    const [row] = await db.select({ count: sql<number>`count(*)::int` }).from(schema.torrents).where(where);
     return row?.count ?? 0;
   };
 
   let whereClause = compose(searchCondition);
-  // The count is needed for pagination anyway: we do it first and it doubles
-  // as the probe for the fallback. Probing separately would have added a query
-  // to every single-word search, including the 95% that find their result
-  // first time.
   let total = await countRows(whereClause);
+  let usedFuzzy = false;
   if (total === 0 && fuzzyFallback) {
     whereClause = compose(fuzzyFallback);
     total = await countRows(whereClause);
+    usedFuzzy = true;
   }
-
-  // Get torrents with optional search.
-  // Ordering lives in `utils/torrentSort` so the key-to-SQL mapping can be
-  // tested without a request; see the notes there on why the swarm columns read
-  // the collector's snapshot and why every non-default sort carries a
-  // tiebreaker.
-  const orderByClause = buildTorrentOrderBy(query.sortBy, query.order);
-
-  /**
-   * The pinned block, page 1 only, and under the SAME filters as the flow —
-   * a release pinned site-wide has no business appearing in a search for
-   * something else, and a member filtering by category is asking a question
-   * that a pin does not override.
-   *
-   * Capped hard: pinning is an editorial act and a page whose first screen is
-   * all pins is a page with no listing on it.
-   */
+  // Ce qu'on cherche en vain, compté pour l'administration : la première page,
+  // un texte d'au moins trois caractères (une lettre en cours de frappe n'est
+  // pas une recherche), et AUCUN autre filtre — « frieren » sous « mes
+  // favoris » qui ne rend rien ne dit pas que Frieren manque au catalogue.
+  const textOnly =
+    !query.categoryId && !query.tag && !query.tagGroups && !query.imdbid && !query.tmdbid && !query.tvdbid &&
+    !query.uploader && query.year === undefined && query.season === undefined && query.episode === undefined &&
+    query.minSeeders === undefined && !query.freeleech && !query.notTaken && !query.hideSuperseded &&
+    !query.favorites && !query.groupKey && !query.since;
+  if (query.search && textOnly && query.page === 1 && total === 0) void recordSearchMiss(query.search, viewer.id);
+
+  const orderByClause = buildTorrentOrderBy(query.sortBy, query.order, {
+    rank: usedFuzzy ? rankFuzzy : rankExact,
+  });
   const pinnedRows =
     query.page === 1
       ? await db.query.torrents.findMany({
@@ -315,90 +90,22 @@ export default defineEventHandler(async (event) => {
           limit: MAX_PINNED,
         })
       : [];
-
   const torrents = await db.query.torrents.findMany({
     where: whereClause,
-    // Negative projection: select every column EXCEPT the raw .torrent
-    // blob. Without this drizzle pulls `torrent_data` (bytea) for every
-    // row and Nitro serialises each as a {"type":"Buffer","data":[...]}
-    // byte array ~4x its size — shipping the full file list + piece
-    // hashes of every torrent to each member and turning a single
-    // `?limit=100` into a multi-hundred-MB response (finding M4). Only
-    // the gated download route reads torrent_data.
     columns: { torrentData: false },
-    with: {
-      category: true,
-      torrentTags: { with: { tag: true } },
-    },
+    with: { category: true, torrentTags: { with: { tag: true } } },
     orderBy: orderByClause,
     limit: query.limit,
     offset,
   });
 
-  // `total` was already computed above: it is what gates the fuzzy fallback.
-
-  // Pinned rows and flow rows are enriched as one list — one Redis round of
-  // stats, one favourites query — then split back apart at the end. Doing it
-  // twice would double both for a block that is usually empty.
-  const allRows = [...pinnedRows, ...torrents];
-
-  // Enrich with live stats from Redis. Tolerate partial failure: a Redis hiccup
-  // for one torrent should not fail the whole listing — fall back to zeroes.
-  const settled = await Promise.allSettled(
-    allRows.map((t) => getStats(t.infoHash))
-  );
-
-  // Bulk-lookup the viewer's favorited torrent_ids among the page
-  // slice — one indexed query for the whole page, then a `Set`
-  // membership check per row when projecting. Keeps the star
-  // toggle's filled/outline state authoritative without a
-  // per-row round-trip.
-  let favoritedSet = new Set<string>();
-  if (allRows.length > 0) {
-    const rows = await db
-      .select({ torrentId: schema.torrentFavorites.torrentId })
-      .from(schema.torrentFavorites)
-      .where(
-        and(
-          eq(schema.torrentFavorites.userId, user.id),
-          inArray(
-            schema.torrentFavorites.torrentId,
-            allRows.map((t) => t.id),
-          ),
-        ),
-      );
-    favoritedSet = new Set(rows.map((r) => r.torrentId));
-  }
-
-  const enriched = allRows.map((torrent, i) => {
-    const r = settled[i];
-    const stats =
-      r.status === 'fulfilled'
-        ? r.value
-        : { seeders: 0, leechers: 0, completed: 0 };
-    const tags = torrent.torrentTags?.map((tt) => tt.tag) ?? [];
-    return {
-      ...torrent,
-      torrentTags: undefined, // collapse the junction-table noise
-      tags,
-      stats: {
-        seeders: stats.seeders,
-        leechers: stats.leechers,
-        completed: stats.completed,
-      },
-      viewerFavorited: favoritedSet.has(torrent.id),
-    };
-  });
-
+  const enriched = await enrichListing([...pinnedRows, ...torrents], viewer);
   return {
-    // Split back apart in the order they went in.
     pinned: enriched.slice(0, pinnedRows.length),
     data: enriched.slice(pinnedRows.length),
     pagination: {
       page: query.page,
       limit: query.limit,
-      // Pinned rows are outside this count, which is what keeps the page
-      // count honest about the flow the reader is paging through.
       total,
       pages: Math.ceil(total / query.limit),
     },
diff --git a/apps/api/routes/api/torrents/index.post.ts b/apps/api/routes/api/torrents/index.post.ts
index 222cebb6..9c2449ce 100644
--- a/apps/api/routes/api/torrents/index.post.ts
+++ b/apps/api/routes/api/torrents/index.post.ts
@@ -626,6 +626,7 @@ export default defineEventHandler(async (event) => {
       tmdbId,
       tvdbId,
       uploaderId: user.id,
+      ...seriesPosition(name),
     });
     // And the IRC channel. A fresh upload carries no per-torrent buff of its
     // own — those are a moderation action — so the three multiplier fields are
diff --git a/apps/api/test/catalogueFilters.test.ts b/apps/api/test/catalogueFilters.test.ts
new file mode 100644
index 00000000..94f8f7ee
--- /dev/null
+++ b/apps/api/test/catalogueFilters.test.ts
@@ -0,0 +1,114 @@
+import { describe, it, expect } from 'vitest';
+import { PgDialect } from 'drizzle-orm/pg-core';
+import type { SQL } from 'drizzle-orm';
+import { filterConditions, tagGroupsCondition, YEAR_IN_NAME_RE, yearInNameRe, isFlag } from '../utils/torrentListing';
+import { boundedTagGroups } from '../utils/schemas';
+
+/**
+ * Les prédicats du catalogue, rendus en SQL par le dialecte que la requête
+ * emploie vraiment.
+ *
+ * Ces filtres décident ce qu'un membre voit ; ils étaient couverts par rien.
+ * Ce qui compte ici n'est pas la forme du texte mais ce qui est PARAMÉTRÉ
+ * (aucune valeur du membre concaténée), et l'accord entre le filtre et la
+ * facette qui en annonce le compte.
+ */
+const dialect = new PgDialect();
+const render = (chunk: SQL) => dialect.sqlToQuery(chunk);
+const viewer = { id: 'viewer-1', isAdmin: false, isModerator: false };
+
+describe('filterConditions', () => {
+  it('cherche l’année dans le nom, jamais collée à une résolution', async () => {
+    const [cond] = await filterConditions({ year: 2024 }, viewer);
+    const q = render(cond!);
+    // L'année part en PARAMÈTRE, et le motif est celui que la facette partage.
+    expect(q.params).toEqual([yearInNameRe(2024)]);
+    expect(q.sql).not.toContain('2024');
+    /*
+     * Les deux motifs disent la même chose, et ce qu'ils disent tient à quatre
+     * regards : pas de chiffre avant ni après (`12019`, `x20230`), et pas de
+     * `x`/`X` collé à un chiffre de l'autre côté — sinon `1920x1080` remplit un
+     * lot « 1920 » qui ne parle de rien, dans les deux casses.
+     */
+    for (const re of [YEAR_IN_NAME_RE, yearInNameRe(2024)]) {
+      expect(re).toContain('(?<![0-9])');
+      expect(re).toContain('(?<![0-9][xX])');
+      expect(re).toContain('(?![0-9])');
+      expect(re).toContain('(?![xX][0-9])');
+    }
+  });
+
+  it('borne `since` à ses trois fenêtres et ignore tout le reste', async () => {
+    for (const [key, interval] of [
+      ['24h', "interval '24 hours'"],
+      ['7d', "interval '7 days'"],
+      ['30d', "interval '30 days'"],
+    ] as const) {
+      const conds = await filterConditions({ since: key }, viewer);
+      expect(render(conds[0]!).sql).toContain(interval);
+    }
+    // Une clé inconnue ne filtre rien — et surtout n'atteint pas `sql.raw`.
+    expect(await filterConditions({ since: 'evil' }, viewer)).toHaveLength(0);
+    // Une propriété héritée d'Object n'est pas une fenêtre.
+    expect(await filterConditions({ since: 'constructor' }, viewer)).toHaveLength(0);
+  });
+
+  it('rapporte les favoris et les prises au membre qui regarde, par paramètre', async () => {
+    const [fav] = await filterConditions({ favorites: '1' }, viewer);
+    expect(render(fav!).params).toContain('viewer-1');
+    const [taken] = await filterConditions({ notTaken: 'true' }, viewer);
+    expect(render(taken!).params).toContain('viewer-1');
+    // Un drapeau n'est vrai que sous ces deux formes.
+    expect(isFlag('1')).toBe(true);
+    expect(isFlag('true')).toBe(true);
+    expect(isFlag('yes')).toBe(false);
+    expect(await filterConditions({ favorites: 'yes' }, viewer)).toHaveLength(0);
+  });
+
+  it('sélectionne les releases d’une œuvre par ses colonnes, pas par la clé calculée', async () => {
+    const [cond] = await filterConditions({ groupKey: 'tmdb:tv/209867', groupScope: 'season' }, viewer);
+    const q = render(cond!);
+    // L'identifiant tel que la colonne le porte, en paramètre, et les autres
+    // sources écartées : c'est ce qui rend le prédicat indexable.
+    expect(q.params).toEqual(['tv/209867']);
+    expect(q.sql).toContain('"igdb_id" IS NULL');
+    // `groupKeySql` est un CASE : le voir ici voudrait dire qu'aucun index ne sert.
+    expect(q.sql).not.toContain('CASE');
+    // La découpe « saison » exige une saison sans épisode.
+    expect(q.sql).toMatch(/season/);
+  });
+
+  it('n’ajoute rien pour une requête vide', async () => {
+    expect(await filterConditions({}, viewer)).toHaveLength(0);
+  });
+});
+
+describe('tagGroupsCondition', () => {
+  it('lit « OU dans un groupe, ET entre les groupes »', () => {
+    const q = render(tagGroupsCondition('hevc,x265;1080p')!);
+    // Deux EXISTS liés par AND, et les slugs en paramètres.
+    expect(q.sql.match(/EXISTS/g)).toHaveLength(2);
+    expect(q.params).toEqual(expect.arrayContaining(['hevc', 'x265', '1080p']));
+  });
+
+  it('dédoublonne, ignore les vides, et ne rend rien quand il ne reste rien', () => {
+    const q = render(tagGroupsCondition('hevc,hevc,;;')!);
+    expect(q.sql.match(/EXISTS/g)).toHaveLength(1);
+    expect(q.params.filter((p) => p === 'hevc')).toHaveLength(1);
+    expect(tagGroupsCondition(';;')).toBeNull();
+    expect(tagGroupsCondition('')).toBeNull();
+  });
+});
+
+describe('boundedTagGroups', () => {
+  it('accepte huit groupes de dix, refuse au-delà', () => {
+    // Le coût est linéaire en groupes ET en synonymes : les facettes lancent
+    // une requête par groupe, chacune portant les autres en EXISTS.
+    expect(boundedTagGroups(Array(8).fill('a').join(';'))).toBe(true);
+    expect(boundedTagGroups(Array(9).fill('a').join(';'))).toBe(false);
+    expect(boundedTagGroups(Array(10).fill('a').join(','))).toBe(true);
+    expect(boundedTagGroups(Array(11).fill('a').join(','))).toBe(false);
+    // Les groupes vides ne comptent pas : `a;;;` reste un groupe.
+    expect(boundedTagGroups('a;;;;;;;;;;;;')).toBe(true);
+  });
+});
diff --git a/apps/api/test/clientIp.test.ts b/apps/api/test/clientIp.test.ts
index 7c97d68d..dd87fd72 100644
--- a/apps/api/test/clientIp.test.ts
+++ b/apps/api/test/clientIp.test.ts
@@ -130,3 +130,58 @@ describe('TRUST_PROXY on', () => {
     expect(getClientIP(event)).toBe('203.0.113.9');
   });
 });
+
+// Le rendu serveur n'est pas un client.
+//
+// Le compteur d'abus est par adresse, et le conteneur web n'en a qu'une pour
+// tout le site. Mesuré sur la pile e2e : quatre requêtes d'API par page vue
+// s'y accumulaient, donc vingt-cinq pages en dix secondes suffisaient à mettre
+// l'instance entière sur liste noire. Le discriminant retenu — pair socket
+// privé ET aucun en-tête de transfert — vient de ce que le proxy du conteneur
+// web fait déjà : il pose `x-forwarded-for` sur ce qu'il RELAIE, et rien sur
+// ce qu'il émet pour lui-même.
+describe('isInternalOrigin', () => {
+  it('reconnaît une requête émise par le rendu serveur', async () => {
+    const { isInternalOrigin } = await load({});
+    expect(isInternalOrigin(eventWith({}, '172.22.0.8'))).toBe(true);
+    expect(isInternalOrigin(eventWith({}, '10.0.0.4'))).toBe(true);
+    expect(isInternalOrigin(eventWith({}, '::1'))).toBe(true);
+    expect(isInternalOrigin(eventWith({}, '::ffff:127.0.0.1'))).toBe(true);
+  });
+
+  it('ne reconnaît PAS une requête relayée pour un navigateur', async () => {
+    // C'est le cas d'une pile sans Caddy : le conteneur web relaie les appels
+    // du navigateur et pose le pair qu'il a vu.
+    const { isInternalOrigin } = await load({});
+    expect(
+      isInternalOrigin(
+        eventWith({ 'x-forwarded-for': '203.0.113.9' }, '172.22.0.8'),
+      ),
+    ).toBe(false);
+    for (const h of ['x-real-ip', 'cf-connecting-ip', 'true-client-ip', 'forwarded']) {
+      expect(isInternalOrigin(eventWith({ [h]: '203.0.113.9' }, '172.22.0.8'))).toBe(
+        false,
+      );
+    }
+  });
+
+  it('ne peut pas être obtenu depuis Internet', async () => {
+    // Une adresse publique ne passe pas, avec ou sans en-tête — et ajouter un
+    // en-tête ne fait jamais qu'exempter MOINS.
+    const { isInternalOrigin } = await load({});
+    expect(isInternalOrigin(eventWith({}, '203.0.113.9'))).toBe(false);
+    expect(isInternalOrigin(eventWith({}, '8.8.8.8'))).toBe(false);
+    // 172.32 est PUBLIQUE : la plage privée s'arrête à 172.31.
+    expect(isInternalOrigin(eventWith({}, '172.32.0.1'))).toBe(false);
+    expect(isInternalOrigin(eventWith({}, '172.15.0.1'))).toBe(false);
+  });
+
+  it('ne dépend pas de TRUST_PROXY', async () => {
+    // Le filtre lit le pair SOCKET, jamais la valeur résolue : sinon un client
+    // pourrait se déclarer privé par en-tête dès que TRUST_PROXY est actif.
+    const { isInternalOrigin } = await load({ TRUST_PROXY: 'true' });
+    expect(
+      isInternalOrigin(eventWith({ 'x-forwarded-for': '10.0.0.9' }, '203.0.113.9')),
+    ).toBe(false);
+  });
+});
diff --git a/apps/api/test/groupSort.test.ts b/apps/api/test/groupSort.test.ts
index 167b4237..eb58a748 100644
--- a/apps/api/test/groupSort.test.ts
+++ b/apps/api/test/groupSort.test.ts
@@ -20,8 +20,9 @@ describe('buildGroupOrderBy', () => {
   it('reads the newest release descending and the oldest ascending', () => {
     // Anything else makes "oldest first" rank works by their most recent
     // upload, which is not what the phrase means.
-    expect(render('age', 'desc')).toBe('latest DESC');
-    expect(render('age', 'asc')).toBe('oldest ASC');
+    // `gkey` ferme le tri : deux œuvres publiées à la même seconde ne permutent plus entre pages.
+    expect(render('age', 'desc')).toBe('latest DESC, gkey ASC');
+    expect(render('age', 'asc')).toBe('oldest ASC, gkey ASC');
   });
 
   it('sorts the swarm columns on the group total, not on any one release', () => {
@@ -53,7 +54,7 @@ describe('buildGroupOrderBy', () => {
       expect(render(key, 'desc')).toContain('latest DESC');
     }
     // `age` needs no second key: it already is the tiebreaker.
-    expect(render('age', 'desc')).not.toContain(',');
+    expect(render('age', 'desc')).not.toContain('latest DESC, latest');
   });
 
   it('flips direction and null placement together', () => {
diff --git a/apps/api/test/metadataUpstream.test.ts b/apps/api/test/metadataUpstream.test.ts
new file mode 100644
index 00000000..f82382cf
--- /dev/null
+++ b/apps/api/test/metadataUpstream.test.ts
@@ -0,0 +1,84 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+/**
+ * Une panne amont n'est pas une absence.
+ *
+ * Mesuré sur la pile e2e : une rafale de recherches au chargement du catalogue
+ * a expiré à huit secondes, et chaque expiration était retenue comme « pas de
+ * fiche » pendant une heure — trente fiches sans affiche pour un réseau qui a
+ * toussé. Le 404, lui, doit rester retenu une heure : c'est une vraie absence.
+ */
+const store = new Map<string, { value: string; ttl: number }>();
+vi.mock('../utils/server', () => ({
+  redis: {
+    get: async (key: string) => store.get(key)?.value ?? null,
+    setex: async (key: string, ttl: number, value: string) => {
+      store.set(key, { value, ttl });
+      return 'OK';
+    },
+    set: async () => 'OK',
+    del: async () => 1,
+  },
+}));
+
+async function load() {
+  vi.resetModules();
+  process.env.TMDB_API_KEY = 'test-key';
+  return await import('../utils/metadata/tmdb');
+}
+
+const written = () => [...store.entries()].map(([key, e]) => ({ key, ...e }));
+
+beforeEach(() => store.clear());
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+  delete process.env.TMDB_API_KEY;
+});
+
+describe('TMDB : absence contre panne', () => {
+  it('un 404 est une absence, retenue une heure', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.stubGlobal('fetch', async () => new Response('', { status: 404 }));
+    const { tmdbSource } = await load();
+    expect(await tmdbSource.lookup('movie/1', 'movie')).toBeNull();
+    const [entry] = written();
+    expect(entry?.value).toBe('__null__');
+    expect(entry?.ttl).toBe(3600);
+  });
+
+  it('un délai dépassé est une panne, retenue deux minutes, et ne casse rien', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.stubGlobal('fetch', async () => {
+      throw new DOMException('The operation was aborted due to timeout', 'TimeoutError');
+    });
+    const { tmdbSource } = await load();
+    expect(await tmdbSource.lookup('tv/65942', 'tv')).toBeNull();
+    const [entry] = written();
+    expect(entry?.value).toBe('__null__');
+    expect(entry?.ttl).toBe(120);
+  });
+
+  it('un 503 amont aussi, sur une recherche', async () => {
+    vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.stubGlobal('fetch', async () => new Response('busy', { status: 503 }));
+    const { tmdbSource } = await load();
+    expect(await tmdbSource.search('frieren', 'tv')).toEqual([]);
+    expect(written()[0]?.ttl).toBe(120);
+  });
+
+  it('une réponse vaut toujours vingt-quatre heures', async () => {
+    vi.stubGlobal(
+      'fetch',
+      async () =>
+        new Response(JSON.stringify({ id: 1, name: 'Frieren', first_air_date: '2023-09-29' }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        }),
+    );
+    const { tmdbSource } = await load();
+    const meta = await tmdbSource.lookup('tv/1', 'tv');
+    expect(meta?.title).toBe('Frieren');
+    expect(written()[0]?.ttl).toBe(86400);
+  });
+});
diff --git a/apps/api/test/torrentSort.test.ts b/apps/api/test/torrentSort.test.ts
index 09dd4b64..869b16c3 100644
--- a/apps/api/test/torrentSort.test.ts
+++ b/apps/api/test/torrentSort.test.ts
@@ -1,3 +1,4 @@
+import { sql } from 'drizzle-orm';
 /**
  * The catalogue listing's ordering. Rendered to SQL text through the same
  * dialect the query builder uses, so these assertions read the statement
@@ -24,14 +25,15 @@ describe('buildTorrentOrderBy', () => {
     expect(primary).toContain('moderated_at');
     expect(primary).toContain('created_at');
     expect(primary).toContain('DESC');
-    // `age` is its own tiebreaker, so it must not be repeated.
-    expect(rest).toHaveLength(0);
+    // L'identifiant ferme le tri : deux dates égales ne permutent plus entre pages.
+    expect(rest).toHaveLength(1);
+    expect(rest[0]).toContain('"id"');
   });
 
   it('carries a stable tiebreaker on every other key', () => {
-    for (const key of TORRENT_SORT_KEYS.filter((k) => k !== 'age')) {
+    for (const key of TORRENT_SORT_KEYS.filter((k) => k !== 'age' && k !== 'relevance')) {
       const clauses = render(key, 'desc');
-      expect(clauses).toHaveLength(2);
+      expect(clauses).toHaveLength(3);
       // Ties resolve on availability date, descending, whatever the primary
       // direction is — otherwise rows with equal values can swap between pages.
       expect(clauses[1]).toMatch(/coalesce/i);
@@ -39,6 +41,13 @@ describe('buildTorrentOrderBy', () => {
     }
   });
 
+  it('relevance ranks by the text-search score, and is plain age without one', () => {
+    // Sans texte tapé, la pertinence n'existe pas : c'est la nouveauté, une clause.
+    expect(buildTorrentOrderBy('relevance', 'desc')).toHaveLength(2);
+    const ranked = buildTorrentOrderBy('relevance', 'desc', { rank: sql`1` });
+    expect(ranked).toHaveLength(3);
+  });
+
   it('flips the primary direction and the null placement together', () => {
     const [desc] = render('size', 'desc');
     expect(desc).toContain('DESC');
diff --git a/apps/api/utils/metadata/cached.ts b/apps/api/utils/metadata/cached.ts
new file mode 100644
index 00000000..51beee1c
--- /dev/null
+++ b/apps/api/utils/metadata/cached.ts
@@ -0,0 +1,101 @@
+import { redis } from '../server';
+import { NEG_SENTINEL } from './types';
+import { tmdbLocale } from './tmdb';
+
+/**
+ * Ce que le catalogue sait d'une œuvre SANS appeler personne.
+ *
+ * La fiche d'un torrent remplit le cache des métadonnées (`meta:v1:*`) à la
+ * première visite ; le catalogue lit ce cache, et seulement lui. Une œuvre que
+ * personne n'a encore ouverte n'a pas de titre ici — c'est voulu : vingt
+ * recherches amont par page de résultats, c'est la rafale qui a mis toute une
+ * page sans affiche pendant une heure (voir `META_TTL.ERR_S`).
+ *
+ * Un seul `MGET` pour toute la page : les clés candidates de chaque référence
+ * sont énumérées (les fiches se cachent sous l'indice `tv`, `movie` ou `auto`,
+ * avec l'identifiant préfixé ou nu, dans la langue du visiteur puis en anglais)
+ * et la première valeur trouvée gagne.
+ */
+export interface WorkRef {
+  source: 'tmdb' | 'igdb' | 'openlibrary';
+  id: string;
+}
+
+export interface CachedWork {
+  source: WorkRef['source'];
+  id: string;
+  title: string;
+  year: number | null;
+  posterUrl: string | null;
+  type: string | null;
+  /** « R G B », la couleur dominante de l'affiche telle que la fiche l'a déposée ; null tant qu'aucune fiche n'a été ouverte. */
+  tint: string | null;
+}
+
+export function workRefKey(ref: WorkRef): string {
+  return `${ref.source}:${ref.id}`;
+}
+
+/** La clé de la teinte déposée par la fiche (voir `routes/api/metadata/tint.post.ts`). */
+export const tintKey = (ref: WorkRef) => `meta:v1:tint:${ref.source}:${ref.id}`;
+
+export function candidateKeys(ref: WorkRef, language?: string): string[] {
+  if (ref.source === 'igdb') return [`meta:v1:igdb:${ref.id}`];
+  if (ref.source === 'openlibrary') return [`meta:v1:openlibrary:${ref.id}`];
+  const locales = Array.from(new Set([tmdbLocale(language), tmdbLocale(undefined)]));
+  const m = ref.id.match(/^(movie|tv)\/(\d+)$/);
+  const ids = m ? [ref.id, m[2]!] : [ref.id];
+  const hints = m ? [m[1]!, 'auto'] : ['movie', 'tv', 'auto'];
+  const out: string[] = [];
+  for (const locale of locales) for (const hint of hints) for (const id of ids) out.push(`meta:v1:tmdb:${locale}:${hint}:${id}`);
+  return out;
+}
+
+export async function worksFromCache(
+  refs: WorkRef[],
+  language?: string,
+): Promise<Map<string, CachedWork | null>> {
+  const out = new Map<string, CachedWork | null>();
+  const plan = refs.map((ref) => ({ ref, keys: candidateKeys(ref, language) }));
+  const allKeys = Array.from(new Set([...plan.flatMap((p) => p.keys), ...plan.map((p) => tintKey(p.ref))]));
+  if (allKeys.length === 0) return out;
+  let values: (string | null)[] = [];
+  try {
+    values = await redis.mget(...allKeys);
+  } catch {
+    for (const { ref } of plan) out.set(workRefKey(ref), null);
+    return out;
+  }
+  const byKey = new Map(allKeys.map((k, i) => [k, values[i] ?? null]));
+  for (const { ref, keys } of plan) {
+    let found: CachedWork | null = null;
+    for (const k of keys) {
+      const raw = byKey.get(k);
+      if (!raw || raw === NEG_SENTINEL) continue;
+      try {
+        const m = JSON.parse(raw) as {
+          title?: string;
+          year?: number | null;
+          releaseDate?: string | null;
+          posterUrl?: string | null;
+          type?: string | null;
+        };
+        if (!m?.title) continue;
+        const year =
+          typeof m.year === 'number'
+            ? m.year
+            : m.releaseDate && /^\d{4}/.test(m.releaseDate)
+              ? Number(m.releaseDate.slice(0, 4))
+              : null;
+        const rawTint = byKey.get(tintKey(ref));
+        const tint = rawTint && /^\d{1,3} \d{1,3} \d{1,3}$/.test(rawTint) ? rawTint : null;
+        found = { source: ref.source, id: ref.id, title: m.title, year, posterUrl: m.posterUrl ?? null, type: m.type ?? null, tint };
+        break;
+      } catch {
+        /* entrée illisible : on essaie la suivante */
+      }
+    }
+    out.set(workRefKey(ref), found);
+  }
+  return out;
+}
diff --git a/apps/api/utils/metadata/igdb.ts b/apps/api/utils/metadata/igdb.ts
index cd6e9913..5d0c6a1c 100644
--- a/apps/api/utils/metadata/igdb.ts
+++ b/apps/api/utils/metadata/igdb.ts
@@ -31,6 +31,7 @@ import type {
   MediaTypeHint,
   SearchOptions,
 } from './types';
+import { guarded, UpstreamUnavailableError } from './upstream';
 import { META_TTL, NEG_SENTINEL } from './types';
 import { safeHttpUrl } from './safeUrl';
 
@@ -199,14 +200,16 @@ async function igdbPost<T = any>(path: string, query: string): Promise<T | null>
       body: query,
       signal: AbortSignal.timeout(8000),
     });
+    if (res.status === 404) return null;
     if (!res.ok) {
       console.warn(`[metadata:igdb] ${res.status} on ${path}: ${query}`);
-      return null;
+      throw new UpstreamUnavailableError('igdb', res.status);
     }
     return (await res.json()) as T;
   } catch (err) {
+    if (err instanceof UpstreamUnavailableError) throw err;
     console.warn(`[metadata:igdb] fetch failed for ${path}:`, err);
-    return null;
+    throw new UpstreamUnavailableError('igdb', null);
   }
 }
 
@@ -275,23 +278,25 @@ async function lookupGame(
     /* Redis hiccup */
   }
 
-  const results = await igdbPost<IgdbGame[]>(
-    '/games',
-    `fields ${GAME_FIELDS}; where id = ${id}; limit 1;`
-  );
-  const game = results?.[0] ?? null;
-  const result = game ? normalizeDetail(game) : null;
+  return guarded(cacheKey, null, async () => {
+    const results = await igdbPost<IgdbGame[]>(
+      '/games',
+      `fields ${GAME_FIELDS}; where id = ${id}; limit 1;`
+    );
+    const game = results?.[0] ?? null;
+    const result = game ? normalizeDetail(game) : null;
 
-  try {
-    if (result) {
-      await redis.setex(cacheKey, META_TTL.POS_S, JSON.stringify(result));
-    } else {
-      await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+    try {
+      if (result) {
+        await redis.setex(cacheKey, META_TTL.POS_S, JSON.stringify(result));
+      } else {
+        await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+      }
+    } catch {
+      /* cache write failure non-fatal */
     }
-  } catch {
-    /* cache write failure non-fatal */
-  }
-  return result;
+    return result;
+  });
 }
 
 async function searchGames(
@@ -317,67 +322,69 @@ async function searchGames(
   // result set returns empty if we combine `search` with a `where`
   // filter — so we run the raw search and rank-filter client-side
   // below to push DLCs / mods / expansion-packs down the list.
-  const escaped = escapeApicalypseString(trimmed);
-  const results = await igdbPost<
-    Array<IgdbGame & { category?: number; version_parent?: number }>
-  >(
-    '/games',
-    `fields id,name,slug,summary,cover.image_id,first_release_date,total_rating,url,category,version_parent;
-     search "${escaped}";
-     limit 20;`
-  );
-  // Promote base games (category 0) ahead of expansions, remakes,
-  // mods, etc. — keeps the top of the picker readable without
-  // dropping anything outright (a user uploading a mod still gets
-  // the mod, just lower in the list).
-  const ranked = (results ?? []).slice().sort((a, b) => {
-    const score = (g: { category?: number; version_parent?: number }) => {
-      const cat = g.category ?? 0;
-      // Base games + remakes / remasters / expanded / ports rank
-      // first; expansions and DLCs in the middle; mods last.
-      if (cat === 0 || cat === 8 || cat === 9 || cat === 10 || cat === 11) {
-        return g.version_parent == null ? 0 : 1;
-      }
-      if (cat === 1 || cat === 2 || cat === 4) return 2; // DLC / expansion
-      if (cat === 5) return 4; // mod
-      return 3;
-    };
-    return score(a) - score(b);
-  });
-  const finalHits: MediaSearchHit[] = ranked.slice(0, 8).map((g) => ({
-    source: 'igdb',
-    type: 'game',
-    id: String(g.id),
-    title: g.name,
-    originalTitle: null,
-    year: g.first_release_date
-      ? new Date(g.first_release_date * 1000).getUTCFullYear()
-      : null,
-    overview: g.summary || null,
-    posterUrl: g.cover?.image_id
-      ? igdbImageUrl(g.cover.image_id, COVER_SIZE)
-      : null,
-    voteAverage:
-      typeof g.total_rating === 'number'
-        ? Math.round((g.total_rating / 10) * 10) / 10
+  return guarded(cacheKey, [], async () => {
+    const escaped = escapeApicalypseString(trimmed);
+    const results = await igdbPost<
+      Array<IgdbGame & { category?: number; version_parent?: number }>
+    >(
+      '/games',
+      `fields id,name,slug,summary,cover.image_id,first_release_date,total_rating,url,category,version_parent;
+       search "${escaped}";
+       limit 20;`
+    );
+    // Promote base games (category 0) ahead of expansions, remakes,
+    // mods, etc. — keeps the top of the picker readable without
+    // dropping anything outright (a user uploading a mod still gets
+    // the mod, just lower in the list).
+    const ranked = (results ?? []).slice().sort((a, b) => {
+      const score = (g: { category?: number; version_parent?: number }) => {
+        const cat = g.category ?? 0;
+        // Base games + remakes / remasters / expanded / ports rank
+        // first; expansions and DLCs in the middle; mods last.
+        if (cat === 0 || cat === 8 || cat === 9 || cat === 10 || cat === 11) {
+          return g.version_parent == null ? 0 : 1;
+        }
+        if (cat === 1 || cat === 2 || cat === 4) return 2; // DLC / expansion
+        if (cat === 5) return 4; // mod
+        return 3;
+      };
+      return score(a) - score(b);
+    });
+    const finalHits: MediaSearchHit[] = ranked.slice(0, 8).map((g) => ({
+      source: 'igdb',
+      type: 'game',
+      id: String(g.id),
+      title: g.name,
+      originalTitle: null,
+      year: g.first_release_date
+        ? new Date(g.first_release_date * 1000).getUTCFullYear()
+        : null,
+      overview: g.summary || null,
+      posterUrl: g.cover?.image_id
+        ? igdbImageUrl(g.cover.image_id, COVER_SIZE)
         : null,
-    url: safeHttpUrl(g.url, `https://www.igdb.com/games/${g.slug}`),
-  }));
+      voteAverage:
+        typeof g.total_rating === 'number'
+          ? Math.round((g.total_rating / 10) * 10) / 10
+          : null,
+      url: safeHttpUrl(g.url, `https://www.igdb.com/games/${g.slug}`),
+    }));
 
-  try {
-    if (finalHits.length > 0) {
-      await redis.setex(
-        cacheKey,
-        META_TTL.SEARCH_S,
-        JSON.stringify(finalHits)
-      );
-    } else {
-      await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+    try {
+      if (finalHits.length > 0) {
+        await redis.setex(
+          cacheKey,
+          META_TTL.SEARCH_S,
+          JSON.stringify(finalHits)
+        );
+      } else {
+        await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+      }
+    } catch {
+      /* cache write failure non-fatal */
     }
-  } catch {
-    /* cache write failure non-fatal */
-  }
-  return finalHits;
+    return finalHits;
+  });
 }
 
 /**
@@ -395,22 +402,24 @@ async function resolveSlug(slug: string): Promise<string | null> {
     /* Redis hiccup */
   }
 
-  const escaped = escapeApicalypseString(slug);
-  const results = await igdbPost<Array<{ id: number }>>(
-    '/games',
-    `fields id; where slug = "${escaped}"; limit 1;`
-  );
-  const id = results?.[0]?.id ? String(results[0]!.id) : null;
-  try {
-    if (id) {
-      await redis.setex(cacheKey, META_TTL.POS_S, id);
-    } else {
-      await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+  return guarded(cacheKey, null, async () => {
+    const escaped = escapeApicalypseString(slug);
+    const results = await igdbPost<Array<{ id: number }>>(
+      '/games',
+      `fields id; where slug = "${escaped}"; limit 1;`
+    );
+    const id = results?.[0]?.id ? String(results[0]!.id) : null;
+    try {
+      if (id) {
+        await redis.setex(cacheKey, META_TTL.POS_S, id);
+      } else {
+        await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+      }
+    } catch {
+      /* cache write failure non-fatal */
     }
-  } catch {
-    /* cache write failure non-fatal */
-  }
-  return id;
+    return id;
+  });
 }
 
 export async function normalizeIgdbId(input: unknown): Promise<string | null> {
diff --git a/apps/api/utils/metadata/index.ts b/apps/api/utils/metadata/index.ts
index 80f91d0e..eb6d8fcd 100644
--- a/apps/api/utils/metadata/index.ts
+++ b/apps/api/utils/metadata/index.ts
@@ -10,6 +10,7 @@
 import { imdbSource, tmdbSource, tvdbSource } from './tmdb';
 import { igdbSource } from './igdb';
 import { openlibrarySource } from './openlibrary';
+import { UpstreamUnavailableError } from './upstream';
 import type {
   LookupOptions,
   MediaMetadata,
@@ -19,6 +20,7 @@ import type {
   MediaTypeHint,
   SearchOptions,
 } from './types';
+import { upsertWorkTitles } from './workTitles';
 
 // Types live in `./types` and are imported from there by callers
 // that need them. Re-exporting them through this file would make
@@ -78,7 +80,22 @@ export async function lookupMetadata(
   options?: LookupOptions
 ): Promise<MediaMetadata | null> {
   const src = getSource(source);
-  return src.lookup(id, hint, options);
+  // Une panne amont qui aurait échappé au garde d'une source rend « rien »,
+  // jamais un 500 : la fiche s'affiche sans affiche, elle ne casse pas.
+  try {
+    const meta = await src.lookup(id, hint, options);
+    // Le titre part dans `work_titles` : la recherche du catalogue le lira.
+    // Silencieux : une table indisponible ne doit pas priver la fiche.
+    if (meta?.title) {
+      void upsertWorkTitles(source, id, meta, options?.language).catch((err: Error) =>
+        console.warn('[Metadata] work title upsert failed:', err.message),
+      );
+    }
+    return meta;
+  } catch (err) {
+    if (err instanceof UpstreamUnavailableError) return null;
+    throw err;
+  }
 }
 
 /**
@@ -93,7 +110,12 @@ export async function searchMetadata(
   options?: SearchOptions
 ): Promise<MediaSearchHit[]> {
   const src = getSource(source);
-  return src.search(query, hint, options);
+  try {
+    return await src.search(query, hint, options);
+  } catch (err) {
+    if (err instanceof UpstreamUnavailableError) return [];
+    throw err;
+  }
 }
 
 /**
@@ -105,5 +127,10 @@ export async function normalizeSourceId(
   source: MediaSourceId,
   input: unknown
 ): Promise<string | null> {
-  return getSource(source).normalizeId(input);
+  try {
+    return await getSource(source).normalizeId(input);
+  } catch (err) {
+    if (err instanceof UpstreamUnavailableError) return null;
+    throw err;
+  }
 }
diff --git a/apps/api/utils/metadata/openlibrary.ts b/apps/api/utils/metadata/openlibrary.ts
index 719f5927..fdf2a422 100644
--- a/apps/api/utils/metadata/openlibrary.ts
+++ b/apps/api/utils/metadata/openlibrary.ts
@@ -31,6 +31,7 @@ import type {
   SearchOptions,
 } from './types';
 import { META_TTL, NEG_SENTINEL } from './types';
+import { guarded, UpstreamUnavailableError } from './upstream';
 import { safeHttpUrl } from './safeUrl';
 
 const OL_BASE = 'https://openlibrary.org';
@@ -64,15 +65,16 @@ async function olGet<T = any>(
       headers: { Accept: 'application/json', 'User-Agent': UA },
       signal: AbortSignal.timeout(8000),
     });
+    if (res.status === 404) return null;
     if (!res.ok) {
-      if (res.status === 404) return null;
       console.warn(`[metadata:openlibrary] ${res.status} on ${path}`);
-      return null;
+      throw new UpstreamUnavailableError('openlibrary', res.status);
     }
     return (await res.json()) as T;
   } catch (err) {
+    if (err instanceof UpstreamUnavailableError) throw err;
     console.warn(`[metadata:openlibrary] fetch failed for ${path}:`, err);
-    return null;
+    throw new UpstreamUnavailableError('openlibrary', null);
   }
 }
 
@@ -88,15 +90,16 @@ async function gbGet<T = any>(
       headers: { Accept: 'application/json' },
       signal: AbortSignal.timeout(8000),
     });
+    if (res.status === 404) return null;
     if (!res.ok) {
-      if (res.status === 404) return null;
       console.warn(`[metadata:googlebooks] ${res.status} on ${path}`);
-      return null;
+      throw new UpstreamUnavailableError('googlebooks', res.status);
     }
     return (await res.json()) as T;
   } catch (err) {
+    if (err instanceof UpstreamUnavailableError) throw err;
     console.warn(`[metadata:googlebooks] fetch failed for ${path}:`, err);
-    return null;
+    throw new UpstreamUnavailableError('googlebooks', null);
   }
 }
 
@@ -379,32 +382,34 @@ async function lookupBook(
     /* Redis hiccup */
   }
 
-  let result: MediaMetadata | null = null;
+  return guarded(cacheKey, null, async () => {
+    let result: MediaMetadata | null = null;
 
-  // Primary: Open Library.
-  const { bibkey, coverKind } = bibkeyFor(id);
-  const ol = await fetchOlBibkey(bibkey);
-  if (ol && ol.title) {
-    result = olToMedia(id, ol, coverKind);
-  }
+    // Primary: Open Library.
+    const { bibkey, coverKind } = bibkeyFor(id);
+    const ol = await fetchOlBibkey(bibkey);
+    if (ol && ol.title) {
+      result = olToMedia(id, ol, coverKind);
+    }
 
-  // Fallback: Google Books, only for ISBN inputs (GB doesn't speak
-  // Open Library work ids) and only when the operator wired the
-  // API key.
-  if (!result && hasGoogleBooks() && (ISBN13_RE.test(id) || ISBN10_RE.test(id))) {
-    result = await fetchGoogleBooksByIsbn(id);
-  }
+    // Fallback: Google Books, only for ISBN inputs (GB doesn't speak
+    // Open Library work ids) and only when the operator wired the
+    // API key.
+    if (!result && hasGoogleBooks() && (ISBN13_RE.test(id) || ISBN10_RE.test(id))) {
+      result = await fetchGoogleBooksByIsbn(id);
+    }
 
-  try {
-    if (result) {
-      await redis.setex(cacheKey, META_TTL.POS_S, JSON.stringify(result));
-    } else {
-      await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+    try {
+      if (result) {
+        await redis.setex(cacheKey, META_TTL.POS_S, JSON.stringify(result));
+      } else {
+        await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+      }
+    } catch {
+      /* cache write failure non-fatal */
     }
-  } catch {
-    /* cache write failure non-fatal */
-  }
-  return result;
+    return result;
+  });
 }
 
 // ── Search ───────────────────────────────────────────────────
@@ -503,42 +508,44 @@ async function searchBooks(
 
   // Primary: Open Library `/search.json`. Constrain by year when
   // we have one — disambiguates re-issues with the same title.
-  const olParams: Record<string, string> = {
-    title: trimmed,
-    limit: '12',
-  };
-  if (year) olParams.first_publish_year = String(year);
-  const ol = await olGet<OlSearchResponse>('/search.json', olParams);
-  let hits = (ol?.docs ?? [])
-    .map(olSearchHit)
-    .filter((h): h is MediaSearchHit => h !== null)
-    .slice(0, 8);
-
-  // Fallback: Google Books — only when OL turned up zero and the
-  // operator opted in. We don't merge results because that risks
-  // duplicates (same book indexed twice) without a clean way to
-  // dedupe across the two id spaces.
-  if (hits.length === 0 && hasGoogleBooks()) {
-    const gb = await gbGet<GbVolumeList>('/volumes', {
-      q: trimmed,
-      maxResults: '8',
-    });
-    hits = (gb?.items ?? [])
-      .map(gbSearchHit)
+  return guarded(cacheKey, [], async () => {
+    const olParams: Record<string, string> = {
+      title: trimmed,
+      limit: '12',
+    };
+    if (year) olParams.first_publish_year = String(year);
+    const ol = await olGet<OlSearchResponse>('/search.json', olParams);
+    let hits = (ol?.docs ?? [])
+      .map(olSearchHit)
       .filter((h): h is MediaSearchHit => h !== null)
       .slice(0, 8);
-  }
 
-  try {
-    if (hits.length > 0) {
-      await redis.setex(cacheKey, META_TTL.SEARCH_S, JSON.stringify(hits));
-    } else {
-      await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+    // Fallback: Google Books — only when OL turned up zero and the
+    // operator opted in. We don't merge results because that risks
+    // duplicates (same book indexed twice) without a clean way to
+    // dedupe across the two id spaces.
+    if (hits.length === 0 && hasGoogleBooks()) {
+      const gb = await gbGet<GbVolumeList>('/volumes', {
+        q: trimmed,
+        maxResults: '8',
+      });
+      hits = (gb?.items ?? [])
+        .map(gbSearchHit)
+        .filter((h): h is MediaSearchHit => h !== null)
+        .slice(0, 8);
     }
-  } catch {
-    /* cache write failure non-fatal */
-  }
-  return hits;
+
+    try {
+      if (hits.length > 0) {
+        await redis.setex(cacheKey, META_TTL.SEARCH_S, JSON.stringify(hits));
+      } else {
+        await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+      }
+    } catch {
+      /* cache write failure non-fatal */
+    }
+    return hits;
+  });
 }
 
 export const openlibrarySource: MediaSource = {
diff --git a/apps/api/utils/metadata/tmdb.ts b/apps/api/utils/metadata/tmdb.ts
index e153141a..e92f6235 100644
--- a/apps/api/utils/metadata/tmdb.ts
+++ b/apps/api/utils/metadata/tmdb.ts
@@ -26,6 +26,7 @@ import type {
   MediaTypeHint,
   SearchOptions,
 } from './types';
+import { guarded, UpstreamUnavailableError } from './upstream';
 import { META_TTL, NEG_SENTINEL } from './types';
 
 const TMDB_BASE = 'https://api.themoviedb.org/3';
@@ -50,7 +51,7 @@ const TMDB_LOCALE_MAP: Record<string, string> = {
   en: 'en-US',
   fr: 'fr-FR',
 };
-function tmdbLocale(language?: string): string {
+export function tmdbLocale(language?: string): string {
   if (!language) return DEFAULT_LOCALE;
   const lc = language.toLowerCase();
   return TMDB_LOCALE_MAP[lc] ?? DEFAULT_LOCALE;
@@ -93,20 +94,28 @@ async function tmdbGet<T = any>(
   const headers: Record<string, string> = { Accept: 'application/json' };
   if (cred.kind === 'bearer') headers.Authorization = `Bearer ${cred.value}`;
 
+  // Un 404 est une ABSENCE : `null`, et l'appelant la retient une heure. Tout
+  // le reste est une PANNE et se lève : l'appelant la retient deux minutes.
+  let res: Response;
   try {
-    const res = await fetch(url, {
+    res = await fetch(url, {
       headers,
       signal: AbortSignal.timeout(8000),
     });
-    if (!res.ok) {
-      if (res.status === 404) return null;
-      console.warn(`[metadata:tmdb] ${res.status} on ${path}`);
-      return null;
-    }
-    return (await res.json()) as T;
   } catch (err) {
     console.warn(`[metadata:tmdb] fetch failed for ${path}:`, err);
-    return null;
+    throw new UpstreamUnavailableError('tmdb', null);
+  }
+  if (res.status === 404) return null;
+  if (!res.ok) {
+    console.warn(`[metadata:tmdb] ${res.status} on ${path}`);
+    throw new UpstreamUnavailableError('tmdb', res.status);
+  }
+  try {
+    return (await res.json()) as T;
+  } catch (err) {
+    console.warn(`[metadata:tmdb] unreadable body on ${path}:`, err);
+    throw new UpstreamUnavailableError('tmdb', res.status);
   }
 }
 
@@ -237,30 +246,32 @@ async function lookupByTmdb(
     /* Redis hiccup — fall through to network */
   }
 
-  const prefixed = id.match(/^(movie|tv)\/(\d+)$/);
-  const inferredType = prefixed ? (prefixed[1] as 'movie' | 'tv') : null;
-  const bareId = prefixed ? prefixed[2]! : id;
-  const tmdbType =
-    hint === 'movie' || hint === 'tv' ? hint : inferredType ?? null;
-
-  let result: MediaMetadata | null = null;
-  if (tmdbType) {
-    result = await fetchDetail(tmdbType, bareId, cred, locale);
-  } else {
-    result = await fetchDetail('movie', bareId, cred, locale);
-    result ??= await fetchDetail('tv', bareId, cred, locale);
-  }
+  return guarded(cacheKey, null, async () => {
+    const prefixed = id.match(/^(movie|tv)\/(\d+)$/);
+    const inferredType = prefixed ? (prefixed[1] as 'movie' | 'tv') : null;
+    const bareId = prefixed ? prefixed[2]! : id;
+    const tmdbType =
+      hint === 'movie' || hint === 'tv' ? hint : inferredType ?? null;
 
-  try {
-    if (result) {
-      await redis.setex(cacheKey, META_TTL.POS_S, JSON.stringify(result));
+    let result: MediaMetadata | null = null;
+    if (tmdbType) {
+      result = await fetchDetail(tmdbType, bareId, cred, locale);
     } else {
-      await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+      result = await fetchDetail('movie', bareId, cred, locale);
+      result ??= await fetchDetail('tv', bareId, cred, locale);
     }
-  } catch {
-    /* cache write failure non-fatal */
-  }
-  return result;
+
+    try {
+      if (result) {
+        await redis.setex(cacheKey, META_TTL.POS_S, JSON.stringify(result));
+      } else {
+        await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+      }
+    } catch {
+      /* cache write failure non-fatal */
+    }
+    return result;
+  });
 }
 
 /**
@@ -285,38 +296,40 @@ async function lookupByExternal(
     /* Redis hiccup — fall through to network */
   }
 
-  const find = await tmdbGet<any>(
-    `/find/${id}`,
-    {
-      external_source: externalSource === 'imdb' ? 'imdb_id' : 'tvdb_id',
-      language: locale,
-    },
-    cred
-  );
-  const movieMatch = find?.movie_results?.[0];
-  const tvMatch = find?.tv_results?.[0];
-
-  let result: MediaMetadata | null = null;
-  if (hint === 'tv' && tvMatch?.id) {
-    result = await fetchDetail('tv', tvMatch.id, cred, locale);
-  } else if (hint === 'movie' && movieMatch?.id) {
-    result = await fetchDetail('movie', movieMatch.id, cred, locale);
-  } else if (movieMatch?.id) {
-    result = await fetchDetail('movie', movieMatch.id, cred, locale);
-  } else if (tvMatch?.id) {
-    result = await fetchDetail('tv', tvMatch.id, cred, locale);
-  }
+  return guarded(cacheKey, null, async () => {
+    const find = await tmdbGet<any>(
+      `/find/${id}`,
+      {
+        external_source: externalSource === 'imdb' ? 'imdb_id' : 'tvdb_id',
+        language: locale,
+      },
+      cred
+    );
+    const movieMatch = find?.movie_results?.[0];
+    const tvMatch = find?.tv_results?.[0];
+
+    let result: MediaMetadata | null = null;
+    if (hint === 'tv' && tvMatch?.id) {
+      result = await fetchDetail('tv', tvMatch.id, cred, locale);
+    } else if (hint === 'movie' && movieMatch?.id) {
+      result = await fetchDetail('movie', movieMatch.id, cred, locale);
+    } else if (movieMatch?.id) {
+      result = await fetchDetail('movie', movieMatch.id, cred, locale);
+    } else if (tvMatch?.id) {
+      result = await fetchDetail('tv', tvMatch.id, cred, locale);
+    }
 
-  try {
-    if (result) {
-      await redis.setex(cacheKey, META_TTL.POS_S, JSON.stringify(result));
-    } else {
-      await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+    try {
+      if (result) {
+        await redis.setex(cacheKey, META_TTL.POS_S, JSON.stringify(result));
+      } else {
+        await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+      }
+    } catch {
+      /* cache write failure non-fatal */
     }
-  } catch {
-    /* cache write failure non-fatal */
-  }
-  return result;
+    return result;
+  });
 }
 
 // ── Search (TMDb only — IMDb / TVDB don't expose a search API) ──
@@ -370,69 +383,71 @@ async function searchTmdb(
     /* Redis hiccup */
   }
 
-  const params: Record<string, string> = {
-    query: trimmed,
-    include_adult: includeAdult ? 'true' : 'false',
-    language: locale,
-    page: '1',
-  };
-  const movieParams = { ...params };
-  const tvParams = { ...params };
-  if (year) {
-    movieParams.year = String(year);
-    tvParams.first_air_date_year = String(year);
-  }
+  return guarded(cacheKey, [], async () => {
+    const params: Record<string, string> = {
+      query: trimmed,
+      include_adult: includeAdult ? 'true' : 'false',
+      language: locale,
+      page: '1',
+    };
+    const movieParams = { ...params };
+    const tvParams = { ...params };
+    if (year) {
+      movieParams.year = String(year);
+      tvParams.first_air_date_year = String(year);
+    }
 
-  type RankedHit = MediaSearchHit & { _pop: number };
-  let hits: RankedHit[] = [];
-  const PAGE_SIZE = 8;
-
-  if (type === 'movie' || !type) {
-    const data = await tmdbGet<any>('/search/movie', movieParams, cred);
-    if (Array.isArray(data?.results)) {
-      hits = hits.concat(
-        data.results.slice(0, PAGE_SIZE).map(
-          (r: any): RankedHit => ({
-            ...normaliseHit('movie', r),
-            _pop: typeof r.popularity === 'number' ? r.popularity : 0,
-          })
-        )
-      );
+    type RankedHit = MediaSearchHit & { _pop: number };
+    let hits: RankedHit[] = [];
+    const PAGE_SIZE = 8;
+
+    if (type === 'movie' || !type) {
+      const data = await tmdbGet<any>('/search/movie', movieParams, cred);
+      if (Array.isArray(data?.results)) {
+        hits = hits.concat(
+          data.results.slice(0, PAGE_SIZE).map(
+            (r: any): RankedHit => ({
+              ...normaliseHit('movie', r),
+              _pop: typeof r.popularity === 'number' ? r.popularity : 0,
+            })
+          )
+        );
+      }
     }
-  }
-  if (type === 'tv' || !type) {
-    const data = await tmdbGet<any>('/search/tv', tvParams, cred);
-    if (Array.isArray(data?.results)) {
-      hits = hits.concat(
-        data.results.slice(0, PAGE_SIZE).map(
-          (r: any): RankedHit => ({
-            ...normaliseHit('tv', r),
-            _pop: typeof r.popularity === 'number' ? r.popularity : 0,
-          })
-        )
-      );
+    if (type === 'tv' || !type) {
+      const data = await tmdbGet<any>('/search/tv', tvParams, cred);
+      if (Array.isArray(data?.results)) {
+        hits = hits.concat(
+          data.results.slice(0, PAGE_SIZE).map(
+            (r: any): RankedHit => ({
+              ...normaliseHit('tv', r),
+              _pop: typeof r.popularity === 'number' ? r.popularity : 0,
+            })
+          )
+        );
+      }
     }
-  }
-
-  if (!type) hits.sort((a, b) => b._pop - a._pop);
-  const finalHits: MediaSearchHit[] = hits
-    .slice(0, PAGE_SIZE)
-    .map(({ _pop, ...rest }) => rest);
 
-  try {
-    if (finalHits.length > 0) {
-      await redis.setex(
-        cacheKey,
-        META_TTL.SEARCH_S,
-        JSON.stringify(finalHits)
-      );
-    } else {
-      await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+    if (!type) hits.sort((a, b) => b._pop - a._pop);
+    const finalHits: MediaSearchHit[] = hits
+      .slice(0, PAGE_SIZE)
+      .map(({ _pop, ...rest }) => rest);
+
+    try {
+      if (finalHits.length > 0) {
+        await redis.setex(
+          cacheKey,
+          META_TTL.SEARCH_S,
+          JSON.stringify(finalHits)
+        );
+      } else {
+        await redis.setex(cacheKey, META_TTL.NEG_S, NEG_SENTINEL);
+      }
+    } catch {
+      /* cache write failure non-fatal */
     }
-  } catch {
-    /* cache write failure non-fatal */
-  }
-  return finalHits;
+    return finalHits;
+  });
 }
 
 function isEnabled(): boolean {
diff --git a/apps/api/utils/metadata/types.ts b/apps/api/utils/metadata/types.ts
index 80cb1be9..57a3f676 100644
--- a/apps/api/utils/metadata/types.ts
+++ b/apps/api/utils/metadata/types.ts
@@ -115,8 +115,36 @@ export const META_TTL = {
   POS_S: 60 * 60 * 24,
   /** Misses — short so an operator can fix a typo without restarting. */
   NEG_S: 60 * 60,
+  /**
+   * Pannes amont — délai dépassé, 5xx, 429, réponse illisible. Deux minutes,
+   * pas une heure : mesuré sur la pile e2e, une rafale de recherches au
+   * chargement du catalogue a expiré à huit secondes, et chaque expiration
+   * était retenue comme « pas de fiche » pendant une heure — trente fiches
+   * sans affiche pour une panne de réseau passagère. Assez long pour ne pas
+   * marteler un amont qui souffre, assez court pour que la fiche revienne
+   * avec lui.
+   */
+  ERR_S: 120,
   /** Search caches — fresh enough for poster swaps. */
   SEARCH_S: 60 * 60 * 6,
 } as const;
 
 export const NEG_SENTINEL = '__null__';
+
+/**
+ * L'amont n'a pas répondu — ce qui n'est PAS « il n'a pas cette fiche ».
+ *
+ * Les clients de source la lèvent sur tout ce qui n'est pas un 200 ou un 404 :
+ * délai dépassé, erreur réseau, 5xx, 429, 401, corps illisible. Les fonctions
+ * qui écrivent le cache la rattrapent (`guarded`) et retiennent l'absence
+ * `META_TTL.ERR_S` secondes seulement, là où un vrai 404 vaut `NEG_S`.
+ */
+export class UpstreamUnavailableError extends Error {
+  constructor(
+    readonly source: string,
+    readonly status: number | null,
+  ) {
+    super(`[metadata:${source}] upstream unavailable${status ? ` (${status})` : ''}`);
+    this.name = 'UpstreamUnavailableError';
+  }
+}
diff --git a/apps/api/utils/metadata/upstream.ts b/apps/api/utils/metadata/upstream.ts
new file mode 100644
index 00000000..4b3ee943
--- /dev/null
+++ b/apps/api/utils/metadata/upstream.ts
@@ -0,0 +1,27 @@
+import { redis } from '../server';
+import { META_TTL, NEG_SENTINEL, UpstreamUnavailableError } from './types';
+
+export { UpstreamUnavailableError };
+
+/**
+ * Exécute une recherche amont ; si elle échoue pour cause de PANNE (et non
+ * d'absence), retient la case vide `META_TTL.ERR_S` secondes sous la même clé
+ * que le résultat, et rend la valeur vide. Toute autre erreur remonte.
+ *
+ * C'est la seule différence entre « TMDB ne répond pas » et « TMDB ne connaît
+ * pas cet identifiant » : la première se réessaie dans deux minutes, la
+ * seconde dans une heure.
+ */
+export async function guarded<T>(cacheKey: string, empty: T, run: () => Promise<T>): Promise<T> {
+  try {
+    return await run();
+  } catch (err) {
+    if (!(err instanceof UpstreamUnavailableError)) throw err;
+    try {
+      await redis.setex(cacheKey, META_TTL.ERR_S, NEG_SENTINEL);
+    } catch {
+      /* l'écriture du cache n'est jamais fatale */
+    }
+    return empty;
+  }
+}
diff --git a/apps/api/utils/metadata/workTitles.ts b/apps/api/utils/metadata/workTitles.ts
new file mode 100644
index 00000000..b713e8b2
--- /dev/null
+++ b/apps/api/utils/metadata/workTitles.ts
@@ -0,0 +1,42 @@
+import { db, schema } from '@trackarr/db';
+import { tmdbLocale } from './tmdb';
+
+/**
+ * Déposer le titre d'une œuvre dans `work_titles`.
+ *
+ * Chaque lookup de métadonnées passe ici : le titre dans la langue demandée,
+ * et le titre original sous la pseudo-langue `orig` quand il diffère — c'est
+ * lui qu'un membre tape le plus souvent (« sousou no frieren »). La recherche
+ * plein texte du catalogue lit ces lignes par l'identifiant externe du torrent.
+ */
+export async function upsertWorkTitles(
+  source: string,
+  externalId: string,
+  meta: { title: string; originalTitle?: string | null; year?: number | null },
+  language?: string,
+): Promise<void> {
+  const title = meta.title?.trim();
+  if (!title) return;
+  const locale = source === 'tmdb' ? tmdbLocale(language) : 'en';
+  const bareId = source === 'tmdb' ? externalId.replace(/^(movie|tv)\//, '') : externalId;
+  const rows = [{ locale, title }];
+  const original = meta.originalTitle?.trim();
+  if (original && original.toLowerCase() !== title.toLowerCase()) rows.push({ locale: 'orig', title: original });
+  for (const row of rows) {
+    await db
+      .insert(schema.workTitles)
+      .values({
+        source,
+        externalId,
+        bareId,
+        locale: row.locale,
+        title: row.title,
+        originalTitle: original ?? null,
+        year: meta.year ?? null,
+      })
+      .onConflictDoUpdate({
+        target: [schema.workTitles.source, schema.workTitles.externalId, schema.workTitles.locale],
+        set: { title: row.title, originalTitle: original ?? null, year: meta.year ?? null, bareId, updatedAt: new Date() },
+      });
+  }
+}
diff --git a/apps/api/utils/mixedGroups.ts b/apps/api/utils/mixedGroups.ts
index 6439bb6b..80ed42d4 100644
--- a/apps/api/utils/mixedGroups.ts
+++ b/apps/api/utils/mixedGroups.ts
@@ -160,6 +160,14 @@ export interface MixedGroupRow {
   completedTotal: number;
   scopes: ScopeSummary[];
   defaultScope: GroupScope;
+  /**
+   * La découpe du PREMIER torrent du groupe selon le tri demandé : trié par
+   * nouveauté, la découpe de la release la plus récente ; par taille, celle de
+   * la plus grosse. C'est la portée que la carte du catalogue ouvre d'abord —
+   * `defaultScope` (la portée la plus récemment alimentée) reste celle des
+   * autres lecteurs.
+   */
+  firstScope: GroupScope;
 }
 
 export interface MixedListOptions {
@@ -183,6 +191,7 @@ export interface MixedListOptions {
 
 type RawMixedGroup = RawScopeCounts & {
   gkey: string;
+  first_scope: string | null;
   release_count: number;
   local_count: number;
   partner_count: number;
@@ -277,9 +286,26 @@ function remoteProjection(where: SQL, tagged: boolean, windowRows?: number): SQL
  * The min–max span the row displays still reads every source — it is answering
  * a different question, namely whether the copy you want is dead.
  */
-function aggregate(source: SQL): SQL {
+/** L'ordre des releases DANS un groupe, pour désigner la première selon le tri. */
+function firstRowOrder(sortBy: TorrentSortKey, order: SortDirection): SQL {
+  const dir = order === 'asc' ? sql`ASC` : sql`DESC`;
+  const key = {
+    age: sql`live_at`,
+    relevance: sql`live_at`,
+    name: sql`lower(name)`,
+    size: sql`size`,
+    seeders: sql`seeders`,
+    leechers: sql`leechers`,
+    completed: sql`completed`,
+  }[sortBy];
+  // Le nom se trie à l'endroit ; « asc » sur une date ou un nombre est « le plus petit d'abord ».
+  return sortBy === 'name' ? sql`${key} ${order === 'desc' ? sql`DESC` : sql`ASC`}` : sql`${key} ${dir}`;
+}
+
+function aggregate(source: SQL, first: SQL): SQL {
   return sql`
     SELECT gkey,
+           (array_agg(scope ORDER BY ${first}))[1] AS first_scope,
            count(DISTINCT rkey)::int AS release_count,
            count(DISTINCT rkey) FILTER (WHERE is_local)::int AS local_count,
            count(DISTINCT rkey) FILTER (WHERE NOT is_local)::int AS partner_count,
@@ -385,9 +411,9 @@ export async function listMixedGroups(
 
   const rows = (await db.execute<RawMixedGroup>(sql`
     SELECT * FROM (
-      ${aggregate(taggedSource)}
+      ${aggregate(taggedSource, firstRowOrder(opts.sortBy ?? 'age', opts.order ?? 'desc'))}
       UNION ALL
-      ${aggregate(soloSource)}
+      ${aggregate(soloSource, firstRowOrder(opts.sortBy ?? 'age', opts.order ?? 'desc'))}
     ) u
      ORDER BY ${buildGroupOrderBy(opts.sortBy ?? 'age', opts.order ?? 'desc')}
      LIMIT ${opts.limit} OFFSET ${opts.offset}
@@ -433,6 +459,7 @@ export async function listMixedGroups(
         completedTotal: Number(r.completed_total ?? 0),
         scopes,
         defaultScope: pickDefault(scopes),
+        firstScope: (scopes.some((sc) => sc.scope === r.first_scope) ? (r.first_scope as GroupScope) : null) ?? pickDefault(scopes),
       };
     }),
     total: Number(countRow?.total ?? 0),
diff --git a/apps/api/utils/rateLimit.ts b/apps/api/utils/rateLimit.ts
index 98de07a7..cb9660f5 100644
--- a/apps/api/utils/rateLimit.ts
+++ b/apps/api/utils/rateLimit.ts
@@ -96,6 +96,76 @@ const TRUST_PROXY = process.env.TRUST_PROXY === 'true';
  */
 const TRUST_CF_CONNECTING_IP = process.env.TRUST_CF_CONNECTING_IP === 'true';
 
+/**
+ * Les adresses qui ne peuvent pas venir d'Internet.
+ *
+ * Sert UNIQUEMENT à reconnaître notre propre couche de rendu serveur ; ce
+ * n'est pas une autorisation, et rien de sensible n'en dépend.
+ */
+function isPrivateAddress(raw: string): boolean {
+  const ip = normalizeIP(raw);
+  if (ip === '::1' || ip === '127.0.0.1') return true;
+  // fc00::/7 (unique local) et fe80::/10 (lien local).
+  if (/^f[cd]/i.test(ip) || /^fe80:/i.test(ip)) return true;
+  return /^(?:10\.|127\.|192\.168\.|169\.254\.|172\.(?:1[6-9]|2\d|3[01])\.)/.test(ip);
+}
+
+/** Tout en-tête par lequel un intermédiaire annonce POUR QUI il parle. */
+const FORWARDED_CLIENT_HEADERS = [
+  'x-forwarded-for',
+  'x-real-ip',
+  'cf-connecting-ip',
+  'true-client-ip',
+  'forwarded',
+] as const;
+
+/**
+ * Cette requête vient-elle de notre propre rendu serveur ?
+ *
+ * # Le problème que ça résout
+ *
+ * Le compteur anti-abus est PAR ADRESSE, et l'API ne voit jamais celle du
+ * membre quand c'est le conteneur web qui parle. Mesuré : trois rendus
+ * anonymes de `/privacy` produisent **douze** requêtes sur un compteur unique,
+ * soit quatre par page vue. Avec `DDOS_THRESHOLD` à 100 requêtes en 10
+ * secondes, **vingt-cinq pages vues en dix secondes** suffisaient à mettre
+ * l'instance ENTIÈRE sur liste noire — cinq minutes au premier coup, doublé à
+ * chaque récidive jusqu'à vingt-quatre heures. Le site se coupait tout seul,
+ * et le journal ne disait rien d'autre que « Blocked blacklisted IP ».
+ *
+ * # Le discriminant, et pourquoi il n'est pas falsifiable
+ *
+ * Deux populations arrivent du conteneur web, et le proxy `/api/[...path]`
+ * les distingue déjà sans le savoir :
+ *
+ *   - une requête qu'il RELAIE pour un navigateur a un pair observé, donc il
+ *     pose `x-forwarded-for` ;
+ *   - une requête que le rendu serveur émet pour lui-même n'a pas de pair,
+ *     donc AUCUN en-tête de transfert n'est posé.
+ *
+ * Les deux moitiés ont été mesurées : le compteur du conteneur web n'existe
+ * que pour la seconde, celui du pair pour la première.
+ *
+ * De l'extérieur, aucune des deux conditions ne se force. L'adresse socket ne
+ * se choisit pas — un client d'Internet ne peut pas émettre depuis 172.16/12 —
+ * et Caddy pose `X-Forwarded-For` sur TOUT ce qu'il relaie, donc une requête
+ * de navigateur n'arrive jamais sans. Ajouter un en-tête ne fait jamais
+ * qu'exempter MOINS.
+ *
+ * Ce qui reste : un voisin de réseau (autre conteneur, machine du même LAN si
+ * l'exploitant expose l'API) échappe au compteur grossier. Il reste soumis aux
+ * limites par route et aux bannissements d'adresse, et quelqu'un qui est DÉJÀ
+ * dans le réseau a de meilleurs leviers que celui-là.
+ */
+export function isInternalOrigin(event: any): boolean {
+  const peer = event?.node?.req?.socket?.remoteAddress;
+  if (!peer || !isPrivateAddress(peer)) return false;
+  for (const name of FORWARDED_CLIENT_HEADERS) {
+    if (getHeader(event, name)) return false;
+  }
+  return true;
+}
+
 /**
  * Extract client IP. Honors proxy headers only if TRUST_PROXY=true, and
  * CF-Connecting-IP only if TRUST_CF_CONNECTING_IP=true on top of that.
diff --git a/apps/api/utils/savedSearchFanout.ts b/apps/api/utils/savedSearchFanout.ts
index f471140d..0d07018a 100644
--- a/apps/api/utils/savedSearchFanout.ts
+++ b/apps/api/utils/savedSearchFanout.ts
@@ -37,6 +37,7 @@ import { db, schema } from '@trackarr/db';
 import { notify } from './notify';
 import { FANOUT_CONCURRENCY, withConcurrency } from './fanout';
 import { adultCategoryIds } from './adultContent';
+import { ftsVector } from '~~/utils/search';
 
 export interface SavedSearchCandidate {
   id: string;
@@ -47,6 +48,9 @@ export interface SavedSearchCandidate {
   tmdbId: string | null;
   tvdbId: string | null;
   uploaderId: string | null;
+  /** La découpe de la release, pour les alertes posées sur une saison ou un épisode. */
+  season?: number | null;
+  episode?: number | null;
 }
 
 /** Log a warning past this, so a slow sweep is visible before it is a problem. */
@@ -95,27 +99,62 @@ async function runFanout(torrent: SavedSearchCandidate): Promise<void> {
         eq(schema.savedSearches.notify, true),
         or(
           sql`${schema.savedSearches.tsquery} IS NULL`,
-          sql`to_tsvector('simple', ${torrent.name}) @@ to_tsquery('simple', ${schema.savedSearches.tsquery})`
+          // Le même vecteur que l'index et la recherche (points → espaces) :
+          // une alerte « frieren » doit se déclencher sur `Sousou.no.Frieren.S01E10`.
+          sql`${ftsVector(sql`${torrent.name}`)} @@ to_tsquery('simple', ${schema.savedSearches.tsquery})`
         )
       )
     );
 
   if (candidates.length === 0) return;
 
+  // Comme le listing : une catégorie parente couvre ses enfants, et un
+  // identifiant TMDb se compare sans son préfixe `tv/` ou `movie/` (le sélecteur
+  // d'œuvre enregistre le nombre nu, l'envoi garde la forme préfixée).
+  const parentId = torrent.categoryId
+    ? ((await db.query.categories.findFirst({ where: eq(schema.categories.id, torrent.categoryId), columns: { parentId: true } }))?.parentId ?? null)
+    : null;
+  /*
+   * Deux identifiants TMDb se comparent SANS leur préfixe seulement quand l'un
+   * des deux n'en a pas : le sélecteur d'œuvre enregistre le nombre nu, l'envoi
+   * garde `tv/209867`. Quand les deux sont préfixés, `movie/603` et `tv/603`
+   * sont deux œuvres différentes et doivent le rester.
+   */
+  const bare = (v: string) => v.replace(/^(movie|tv)\//, '');
+  const tmdbMatches = (want: string, has: string | null | undefined) => {
+    if (!has) return false;
+    if (want.includes('/') && has.includes('/')) return want === has;
+    return bare(want) === bare(has);
+  };
   // The structured half, in memory.
   const matched = candidates.filter((f) => {
     if (f.userId === torrent.uploaderId) return false;
-    if (f.categoryId && f.categoryId !== torrent.categoryId) return false;
+    if (f.categoryId && f.categoryId !== torrent.categoryId && f.categoryId !== parentId) return false;
     if (f.imdbId && f.imdbId !== torrent.imdbId) return false;
-    if (f.tmdbId && f.tmdbId !== torrent.tmdbId) return false;
+    if (f.tmdbId && !tmdbMatches(f.tmdbId, torrent.tmdbId)) return false;
     if (f.tvdbId && f.tvdbId !== torrent.tvdbId) return false;
     const wanted = f.tags ?? [];
     if (wanted.length && !wanted.every((t) => torrentTags.has(t))) return false;
+    // Les critères de la barre : un groupe d'étiquettes est satisfait par l'un
+    // de ses synonymes (OU), tous les groupes doivent l'être (ET) ; saison,
+    // épisode et uploadeur à l'égal ; l'année dans le nom, entre deux non-chiffres.
+    if (f.tagGroups) {
+      const groups = f.tagGroups
+        .split(';')
+        .map((g) => g.split(',').filter(Boolean))
+        .filter((g) => g.length > 0);
+      if (!groups.every((g) => g.some((slug) => torrentTags.has(slug)))) return false;
+    }
+    if (f.season != null && f.season !== (torrent.season ?? null)) return false;
+    if (f.episode != null && f.episode !== (torrent.episode ?? null)) return false;
+    if (f.year != null && !new RegExp(`(^|[^0-9])${f.year}([^0-9]|$)`).test(torrent.name)) return false;
+    if (f.uploaderId && f.uploaderId !== torrent.uploaderId) return false;
     // A filter with no free text, no category, no tag and no id would match
     // every upload ever. The write path refuses to store one; this is the
     // second line, in case a row predates that or arrives another way.
     const empty =
-      !f.tsquery && !f.categoryId && !f.imdbId && !f.tmdbId && !f.tvdbId && !wanted.length;
+      !f.tsquery && !f.categoryId && !f.imdbId && !f.tmdbId && !f.tvdbId && !wanted.length &&
+      !f.tagGroups && f.season == null && f.episode == null && f.year == null && !f.uploaderId;
     return !empty;
   });
 
diff --git a/apps/api/utils/schemas.ts b/apps/api/utils/schemas.ts
index 21e1ed2b..40002292 100644
--- a/apps/api/utils/schemas.ts
+++ b/apps/api/utils/schemas.ts
@@ -96,6 +96,16 @@ export const torrentUploadSchema = z.object({
   description: z.string().max(10000, 'Description too long').optional(),
 });
 
+/**
+ * Huit groupes de dix synonymes au plus : chaque groupe coûte un EXISTS sur la
+ * table de liaison, et les facettes en lancent un par groupe. Sans borne, une
+ * seule requête pouvait occuper tout le pool de connexions.
+ */
+export function boundedTagGroups(raw: string): boolean {
+  const groups = raw.split(';').filter((g) => g.trim());
+  return groups.length <= 8 && groups.every((g) => g.split(',').filter((x) => x.trim()).length <= 10);
+}
+
 export const torrentQuerySchema = z.object({
   page: z.coerce.number().int().positive().default(1),
   limit: z.coerce.number().int().positive().max(100).default(20),
@@ -125,6 +135,40 @@ export const torrentQuerySchema = z.object({
   // fan out one Redis read per candidate row before it knows which page it is
   // serving. Displayed counts stay live — only the ordering is as of the last
   // collection pass.
+  /*
+   * Ce que la barre du catalogue COMPREND en tapant — voir `searchTokens.ts`
+   * côté web. `tagGroups` : des groupes séparés par `;`, des alternatives par
+   * `,` — `hevc,x265;1080p` veut dire « (hevc OU x265) ET 1080p ». Dans un
+   * groupe, un synonyme absent du vocabulaire de l'instance est simplement
+   * ignoré tant qu'un autre existe — là où `tag` répond « rien » dès qu'un de
+   * ses slugs est inconnu. Les drapeaux sont des chaînes `1`/`true` :
+   * `z.coerce.boolean('false')` vaudrait `true`.
+   */
+  tagGroups: z
+    .string()
+    .max(400)
+    .optional()
+    .refine((v) => !v || boundedTagGroups(v), { message: 'tagGroups: at most 8 groups of 10 alternatives' }),
+  uploader: z.string().trim().min(1).max(64).optional(),
+  year: z.coerce.number().int().min(1900).max(2100).optional(),
+  season: z.coerce.number().int().min(0).max(999).optional(),
+  episode: z.coerce.number().int().min(0).max(9999).optional(),
+  minSeeders: z.coerce.number().int().min(0).max(100000).optional(),
+  freeleech: z.enum(['1', 'true']).optional(),
+  notTaken: z.enum(['1', 'true']).optional(),
+  hideSuperseded: z.enum(['1', 'true']).optional(),
+  /** Les favoris de ce membre seulement. */
+  favorites: z.enum(['1', 'true']).optional(),
+  /** Ajoutés depuis peu — le « du jour » du menu Torrents, et ses deux cousins. */
+  since: z.enum(['24h', '7d', '30d']).optional(),
+  /*
+   * Une clé de groupe (`tmdb:tv/209867`, `solo:<signature>`) : les releases
+   * d'une œuvre, avec les mêmes filtres que la page — c'est ce qu'une carte
+   * dépliée de la vue Œuvres demande.
+   */
+  groupKey: z.string().trim().min(1).max(200).optional(),
+  /** Avec `groupKey` : la découpe voulue — à l'épisode, saisons complètes, intégrale. */
+  groupScope: z.enum(['episode', 'season', 'integral', 'all']).optional(),
   sortBy: z.enum(TORRENT_SORT_KEYS).default('age'),
   order: z.enum(['asc', 'desc']).default('desc'),
 });
@@ -205,6 +249,16 @@ export const adminSettingsSchema = z.object({
     .max(4)
     .optional(),
   searchFuzzy: z.boolean().optional(),
+  // Le catalogue : la vue et le tri qu'un membre trouve en arrivant, la taille
+  // d'une page, les facettes du rail. « auto » pour le tri : pertinence dès
+  // qu'un texte est tapé, nouveauté sinon.
+  catalogueDefaultView: z.enum(['grouped', 'simple']).optional(),
+  catalogueDefaultSort: z.enum(['auto', 'age', 'name', 'size', 'seeders', 'leechers', 'completed']).optional(),
+  cataloguePageSize: z.coerce.number().int().min(10).max(50).optional(),
+  catalogueFacets: z
+    .array(z.enum(['category', 'resolution', 'source', 'codec', 'language', 'hdr', 'audio', 'year', 'options']))
+    .max(9)
+    .optional(),
   registrationOpen: z.boolean().optional(),
   inviteEnabled: z.boolean().optional(),
   defaultInvites: z.coerce.number().int().min(0).max(100).optional(),
@@ -213,6 +267,12 @@ export const adminSettingsSchema = z.object({
   maxPeersPerTorrent: z.coerce.number().int().positive().max(1000).optional(),
   peerTTL: z.coerce.number().int().positive().max(86400).optional(),
   minRatio: z.coerce.number().min(0).max(10).optional(),
+  // Hit & Run. En HEURES côté interface, en secondes en base : personne ne
+  // règle un seuil de partage en secondes, et 86400 se lit mal. Bornés à un
+  // an ; zéro heure de seuil veut dire « aucune obligation ».
+  hnrEnabled: z.boolean().optional(),
+  hnrRequiredSeedHours: z.coerce.number().int().min(0).max(8760).optional(),
+  hnrGraceHours: z.coerce.number().int().min(0).max(8760).optional(),
   starterUpload: z.coerce.number().int().min(0).optional(),
   siteName: z.string().min(1).max(500).optional(),
   siteLogo: z.string().min(1).max(100).optional(),
diff --git a/apps/api/utils/searchMisses.ts b/apps/api/utils/searchMisses.ts
new file mode 100644
index 00000000..7afdd254
--- /dev/null
+++ b/apps/api/utils/searchMisses.ts
@@ -0,0 +1,54 @@
+import { sql } from 'drizzle-orm';
+import { db, schema } from '@trackarr/db';
+import { redis } from '~~/utils/server';
+
+/** La table reste sous ce nombre de lignes : au-delà, les moins demandées et les plus anciennes partent. */
+const MAX_ROWS = 5000;
+/** Ce qu'un membre peut faire compter par heure : au-delà, on n'enregistre plus. */
+const PER_USER_PER_HOUR = 30;
+
+/**
+ * Compter une recherche qui n'a rien rendu.
+ *
+ * Normalisée (minuscules, espaces repliés) pour qu'une même intention ne fasse
+ * qu'une ligne ; ignorée sous trois caractères (une frappe en cours) et
+ * au-delà de deux cents (un collage). Un infohash n'est pas une recherche
+ * qu'on peut satisfaire en acquérant quelque chose : ignoré aussi.
+ *
+ * Deux bornes, parce qu'une recherche vide est gratuite à produire : un budget
+ * horaire par membre (une boucle de chaînes aléatoires ne remplit pas la
+ * table), et un plafond global élagué à chaque ligne nouvelle.
+ */
+export async function recordSearchMiss(raw: string, userId: string): Promise<void> {
+  const query = raw.trim().toLowerCase().replace(/\s+/g, ' ');
+  if (query.length < 3 || query.length > 200) return;
+  if (/^[0-9a-f]{40}$/.test(query)) return;
+  try {
+    // `SET NX EX` puis `INCR` : avec `INCR` d'abord et `EXPIRE` ensuite, une
+    // panne entre les deux laissait une clé sans délai — ce membre ne comptait
+    // plus jamais aucune recherche vaine.
+    const budgetKey = `misses:budget:${userId}`;
+    await redis.set(budgetKey, '0', 'EX', 3600, 'NX');
+    const used = await redis.incr(budgetKey);
+    if (used > PER_USER_PER_HOUR) return;
+    // `xmax = 0` : la ligne vient d'être insérée ; sinon c'est le compteur d'une ligne existante.
+    const rows = (await db.execute(sql`
+      INSERT INTO ${schema.searchMisses} (query) VALUES (${query})
+      ON CONFLICT (query) DO UPDATE
+        SET count = ${schema.searchMisses}.count + 1, last_at = now()
+      RETURNING (xmax = 0) AS inserted
+    `)) as unknown as Array<{ inserted: boolean }>;
+    if (rows[0]?.inserted) {
+      await db.execute(sql`
+        DELETE FROM ${schema.searchMisses}
+         WHERE query IN (
+           SELECT query FROM ${schema.searchMisses}
+            ORDER BY count ASC, last_at ASC
+            LIMIT GREATEST(0, (SELECT count(*) FROM ${schema.searchMisses}) - ${MAX_ROWS})
+         )
+      `);
+    }
+  } catch (err) {
+    console.warn('[SearchMisses] record failed:', (err as Error).message);
+  }
+}
diff --git a/apps/api/utils/settings.ts b/apps/api/utils/settings.ts
index e5437950..7644f776 100644
--- a/apps/api/utils/settings.ts
+++ b/apps/api/utils/settings.ts
@@ -257,6 +257,12 @@ export const SETTINGS_KEYS = {
   // Typo fallback. Expensive (word_similarity re-reads many candidate rows):
   // left switchable for large catalogues.
   SEARCH_FUZZY: 'search_fuzzy',
+  // Le catalogue : la vue et le tri à l'arrivée, la taille d'une page, les
+  // facettes du rail (voir `getCatalogueSettings`).
+  CATALOGUE_DEFAULT_VIEW: 'catalogue_default_view',
+  CATALOGUE_DEFAULT_SORT: 'catalogue_default_sort',
+  CATALOGUE_PAGE_SIZE: 'catalogue_page_size',
+  CATALOGUE_FACETS: 'catalogue_facets',
 } as const;
 
 const settingsCache = new Map<
@@ -839,3 +845,49 @@ export async function setRoomSlowModeSeconds(seconds: number) {
     String(Math.max(0, Math.floor(seconds)))
   );
 }
+
+/* ── Le catalogue ─────────────────────────────────────────────────────────── */
+export const CATALOGUE_FACET_KEYS = [
+  'category', 'resolution', 'source', 'codec', 'language', 'hdr', 'audio', 'year', 'options',
+] as const;
+export type CatalogueFacetKey = (typeof CATALOGUE_FACET_KEYS)[number];
+export const CATALOGUE_SORTS = ['auto', 'age', 'name', 'size', 'seeders', 'leechers', 'completed'] as const;
+export type CatalogueSort = (typeof CATALOGUE_SORTS)[number];
+
+export interface CatalogueSettings {
+  /** La vue à l'arrivée : par œuvre, ou release par release. */
+  defaultView: 'grouped' | 'simple';
+  /** « auto » : pertinence dès qu'un texte est tapé, nouveauté sinon. */
+  defaultSort: CatalogueSort;
+  pageSize: number;
+  /** Les facettes du rail, dans l'ordre d'affichage ; vide = aucune. */
+  facets: CatalogueFacetKey[];
+}
+
+/**
+ * Ce que l'opérateur a choisi pour le catalogue, avec les défauts qui valent
+ * quand il n'a rien dit : Œuvres, tri automatique, vingt par page, toutes les
+ * facettes. Une chaîne vide pour les facettes est un choix (aucune), un réglage
+ * absent n'en est pas un — la même règle que les champs de la recherche.
+ */
+export async function getCatalogueSettings(): Promise<CatalogueSettings> {
+  const [view, sort, size, facets] = await Promise.all([
+    getSetting(SETTINGS_KEYS.CATALOGUE_DEFAULT_VIEW),
+    getSetting(SETTINGS_KEYS.CATALOGUE_DEFAULT_SORT),
+    getSetting(SETTINGS_KEYS.CATALOGUE_PAGE_SIZE),
+    getSetting(SETTINGS_KEYS.CATALOGUE_FACETS),
+  ]);
+  const pageSize = Math.min(50, Math.max(10, parseInt(size ?? '', 10) || 20));
+  return {
+    defaultView: view === 'simple' ? 'simple' : 'grouped',
+    defaultSort: (CATALOGUE_SORTS as readonly string[]).includes(sort ?? '') ? (sort as CatalogueSort) : 'auto',
+    pageSize,
+    facets:
+      facets === null || facets === undefined
+        ? [...CATALOGUE_FACET_KEYS]
+        : facets
+            .split(',')
+            .map((f) => f.trim())
+            .filter((f): f is CatalogueFacetKey => (CATALOGUE_FACET_KEYS as readonly string[]).includes(f)),
+  };
+}
diff --git a/apps/api/utils/tags.ts b/apps/api/utils/tags.ts
index 1b51d791..bd3b44f8 100644
--- a/apps/api/utils/tags.ts
+++ b/apps/api/utils/tags.ts
@@ -17,7 +17,7 @@
  *     to the same tag.
  */
 import { db, schema } from '@trackarr/db';
-import { inArray } from 'drizzle-orm';
+import { inArray, sql, type SQL } from 'drizzle-orm';
 import { randomUUID } from 'crypto';
 
 export const MAX_TAG_NAME_LENGTH = 30;
@@ -125,3 +125,49 @@ export async function resolveTagsByName(
     created: toCreate.length,
   };
 }
+
+/**
+ * Le prédicat « ce torrent porte TOUS ces tags », partagé.
+ *
+ * Il vivait en un seul exemplaire, dans le listing plat. La vue GROUPÉE ne
+ * connaissait pas du tout le paramètre `tag` — zod le retirait en silence —
+ * donc `/torrents?tag=2160p&v=grouped` remontait des livres et de la musique.
+ * Le filtre n'était pas cassé : il n'existait pas de ce côté-là.
+ *
+ * Le voici en un endroit, pour que les deux vues ne puissent plus diverger.
+ *
+ * Renvoie `null` quand la liste ne contient aucun tag exploitable (le filtre
+ * ne s'applique alors pas), et `sql\`false\`` quand un slug demandé n'existe
+ * pas — aucun torrent ne peut le porter, et un résultat vide est honnête là où
+ * élargir à « on ignore le filtre » ne l'est pas.
+ */
+export async function tagFilterCondition(raw: string): Promise<SQL | null> {
+  const slugs = Array.from(
+    new Set(
+      raw
+        .split(',')
+        .map((s) => slugifyTag(s))
+        .filter(Boolean),
+    ),
+  );
+  if (slugs.length === 0) return null;
+
+  const matched = await db.query.tags.findMany({
+    where: inArray(schema.tags.slug, slugs),
+    columns: { id: true },
+  });
+  if (matched.length !== slugs.length) return sql`false`;
+
+  const tagIds = matched.map((t) => t.id);
+  // `count(distinct tag_id)` plutôt qu'un simple compte : le prédicat reste
+  // juste même si `torrent_tags` venait à porter des doublons.
+  return inArray(
+    schema.torrents.id,
+    db
+      .select({ torrentId: schema.torrentTags.torrentId })
+      .from(schema.torrentTags)
+      .where(inArray(schema.torrentTags.tagId, tagIds))
+      .groupBy(schema.torrentTags.torrentId)
+      .having(sql`count(distinct ${schema.torrentTags.tagId}) = ${tagIds.length}`),
+  ) as SQL;
+}
diff --git a/apps/api/utils/torrentGroups.ts b/apps/api/utils/torrentGroups.ts
index d176ecad..84132847 100644
--- a/apps/api/utils/torrentGroups.ts
+++ b/apps/api/utils/torrentGroups.ts
@@ -307,10 +307,12 @@ export function buildGroupOrderBy(
   const dir = order === 'asc' ? sql`ASC` : sql`DESC`;
   const nulls = order === 'asc' ? sql`NULLS FIRST` : sql`NULLS LAST`;
 
-  if (sortBy === 'age') {
+  // Les groupes n'ont pas de rang plein texte : « pertinence » vaut nouveauté.
+  if (sortBy === 'age' || sortBy === 'relevance') {
     // Both ends of the span, so each direction reads the release a member
     // would point at.
-    return order === 'asc' ? sql`oldest ASC` : sql`latest DESC`;
+    // `gkey` est unique par œuvre : deux dates égales ne permutent plus entre pages.
+    return order === 'asc' ? sql`oldest ASC, gkey ASC` : sql`latest DESC, gkey ASC`;
   }
 
   const key = {
@@ -324,7 +326,7 @@ export function buildGroupOrderBy(
   // `latest DESC` breaks ties: Postgres promises nothing about equal keys, and
   // without it a member paging through "most seeded" can meet the same work
   // twice.
-  return sql`${key} ${dir} ${nulls}, latest DESC`;
+  return sql`${key} ${dir} ${nulls}, latest DESC, gkey ASC`;
 }
 
 /**
diff --git a/apps/api/utils/torrentListing.ts b/apps/api/utils/torrentListing.ts
new file mode 100644
index 00000000..c0ce602b
--- /dev/null
+++ b/apps/api/utils/torrentListing.ts
@@ -0,0 +1,466 @@
+import { db, schema } from '@trackarr/db';
+import { redactUploader } from '~~/utils/uploaderVisibility';
+import { and, eq, gt, inArray, isNull, notInArray, or, sql, type SQL } from 'drizzle-orm';
+import { slugifyTag, tagFilterCondition } from '~~/utils/tags';
+import { normalizeMediaId, tmdbIdBare } from '~~/utils/mediaIds';
+import { getSetting } from '~~/utils/settings';
+import {
+  FTS_CONFIG,
+  SEARCH_FIELDS_SETTING,
+  SEARCH_FUZZY_SETTING,
+  ftsVector,
+  fuzzyTerm,
+  parseSearchFields,
+  parseSearchFuzzy,
+  toPrefixTsQuery,
+} from '~~/utils/search';
+import { adultCategoryIds } from '~~/utils/adultContent';
+import { worksFromCache, workRefKey, type CachedWork, type WorkRef } from '~~/utils/metadata/cached';
+import { groupMemberWhere, parseGroupKey, scopeWhere, type GroupScope } from '~~/utils/torrentGroups';
+
+/**
+ * Le listing des torrents, en pièces réutilisables.
+ *
+ * Le listing plat et la vue groupée ont chacun réécrit les mêmes prédicats, et
+ * la vue groupée a un jour PERDU le filtre par tag sans qu'aucune ligne ne le
+ * dise. Depuis, les conditions vivent ici, une fois : la visibilité (modération,
+ * actif, contenu adulte), les filtres que la barre du catalogue produit, la
+ * recherche plein texte. Les comptes par facette, à venir, les liront aussi.
+ */
+export interface ListingViewer {
+  id: string;
+  isAdmin?: boolean;
+  isModerator?: boolean;
+  language?: string | null;
+}
+
+export interface ListingFilters {
+  categoryId?: string;
+  tag?: string;
+  tagGroups?: string;
+  imdbid?: string;
+  tmdbid?: string;
+  tvdbid?: string;
+  uploader?: string;
+  year?: number;
+  season?: number;
+  episode?: number;
+  minSeeders?: number;
+  freeleech?: string;
+  notTaken?: string;
+  hideSuperseded?: string;
+  groupKey?: string;
+  groupScope?: string;
+  favorites?: string;
+  since?: string;
+}
+
+/**
+ * L'année dans le nom, en expression régulière Postgres.
+ *
+ * Pas de colonne « année » : c'est le nom qui la porte. Deux exigences, et la
+ * facette DOIT utiliser le même motif que le filtre, sinon le compte annoncé
+ * n'est pas celui qu'un clic rend :
+ *   - entre deux non-chiffres, pour que 2023 ne trouve ni 12023 ni x20230 ;
+ *   - jamais collée à un `x` suivi d'un chiffre, sinon `1920x1080` remplissait
+ *     un lot « 1920 » qui ne parle de rien.
+ */
+export const YEAR_IN_NAME_RE =
+  '(?<![0-9])(?<![0-9][xX])((?:19|20)[0-9]{2})(?![0-9])(?![xX][0-9])';
+/** Le même, resserré sur une année précise — ce que le filtre pose. */
+export const yearInNameRe = (year: number): string =>
+  `(?<![0-9])(?<![0-9][xX])${year}(?![0-9])(?![xX][0-9])`;
+
+/** Les fenêtres de `since`, en intervalle Postgres. Une clé inconnue ne filtre rien. */
+export const SINCE_INTERVALS: Record<string, string> = { '24h': '24 hours', '7d': '7 days', '30d': '30 days' };
+const sinceInterval = (key: string): string | null => (Object.hasOwn(SINCE_INTERVALS, key) ? SINCE_INTERVALS[key]! : null);
+
+/**
+ * Combien d'œuvres un texte peut désigner avant qu'on cesse de compter.
+ *
+ * Au-delà, la recherche par titre est tronquée : c'est un mot si commun que la
+ * recherche par nom de fichier répond déjà, et deux mille identifiants dans un
+ * `IN` coûtent plus que ce qu'ils rendent.
+ */
+const WORK_TITLE_MATCH_CAP = 500;
+
+/** `1`/`true` dans une chaîne de requête, et rien d'autre. */
+export const isFlag = (v: unknown): boolean => v === '1' || v === 'true' || v === true;
+
+/**
+ * Un torrent par son hash, ou 404 : la visibilité du listing appliquée à une
+ * route unitaire (historique d'essaim, obligation), pour ne rien confirmer de
+ * ce que la fiche cache.
+ */
+export async function assertVisibleTorrent(
+  infoHash: string,
+  viewer: { id: string; isAdmin?: boolean | null; isModerator?: boolean | null },
+): Promise<{ id: string }> {
+  const vis = await visibilityConditions({ id: viewer.id, isAdmin: !!viewer.isAdmin, isModerator: !!viewer.isModerator });
+  const [row] = await db
+    .select({ id: schema.torrents.id })
+    .from(schema.torrents)
+    .where(and(eq(schema.torrents.infoHash, infoHash), ...vis))
+    .limit(1);
+  if (!row) throw createError({ statusCode: 404, message: 'Torrent not found' });
+  return row;
+}
+
+/** Ce que ce membre a le droit de voir : modération, activité, contenu adulte. */
+export async function visibilityConditions(viewer: ListingViewer): Promise<SQL[]> {
+  const conditions: SQL[] = [];
+  const canSeeUnapproved = !!viewer.isAdmin || !!viewer.isModerator;
+  if (!canSeeUnapproved) {
+    conditions.push(
+      or(eq(schema.torrents.moderationStatus, 'accepted'), eq(schema.torrents.uploaderId, viewer.id))!,
+    );
+    conditions.push(eq(schema.torrents.isActive, true));
+  }
+  const me = await db.query.users.findFirst({
+    where: eq(schema.users.id, viewer.id),
+    columns: { showAdultContent: true },
+  });
+  if (!(me?.showAdultContent ?? false)) {
+    const adultIds = await adultCategoryIds();
+    if (adultIds.length > 0) {
+      conditions.push(
+        or(isNull(schema.torrents.categoryId), notInArray(schema.torrents.categoryId, adultIds))!,
+      );
+    }
+  }
+  return conditions;
+}
+
+/**
+ * `hevc,x265;1080p` → (hevc OU x265) ET 1080p. Chaque groupe est un EXISTS sur
+ * la table de liaison ; un slug inconnu ne correspond à rien, sans forcer le
+ * vide comme `tag` le fait (là, un slug qui n'existe pas est une erreur de
+ * frappe ; ici, ce sont des synonymes dont seuls certains existent).
+ */
+export function tagGroupsCondition(raw: string): SQL | null {
+  const groups = raw
+    .split(';')
+    .map((g) => Array.from(new Set(g.split(',').map((s) => slugifyTag(s)).filter(Boolean))))
+    .filter((g) => g.length > 0);
+  if (groups.length === 0) return null;
+  const parts = groups.map(
+    (slugs) => sql`EXISTS (
+      SELECT 1 FROM ${schema.torrentTags} tt
+      JOIN ${schema.tags} tg ON tg.id = tt.tag_id
+      WHERE tt.torrent_id = ${schema.torrents.id}
+        AND tg.slug IN (${sql.join(slugs.map((s) => sql`${s}`), sql`, `)})
+    )`,
+  );
+  return parts.length === 1 ? parts[0]! : and(...parts)!;
+}
+
+/** Les filtres explicites — catégorie, identifiants, tags, et ceux de la barre. */
+export async function filterConditions(q: ListingFilters, viewer: ListingViewer): Promise<SQL[]> {
+  const conditions: SQL[] = [];
+  if (q.categoryId) {
+    const subcategories = await db.query.categories.findMany({
+      where: eq(schema.categories.parentId, q.categoryId),
+      columns: { id: true },
+    });
+    conditions.push(
+      or(
+        eq(schema.torrents.categoryId, q.categoryId),
+        ...subcategories.map((sub) => eq(schema.torrents.categoryId, sub.id)),
+      )!,
+    );
+  }
+  if (q.imdbid) {
+    const norm = normalizeMediaId('imdb', q.imdbid);
+    conditions.push(norm ? eq(schema.torrents.imdbId, norm) : sql`false`);
+  }
+  if (q.tmdbid) {
+    const norm = normalizeMediaId('tmdb', q.tmdbid);
+    const bare = norm ? tmdbIdBare(norm) : null;
+    conditions.push(
+      norm && bare
+        ? or(
+            eq(schema.torrents.tmdbId, norm),
+            eq(schema.torrents.tmdbId, bare),
+            eq(schema.torrents.tmdbId, `movie/${bare}`),
+            eq(schema.torrents.tmdbId, `tv/${bare}`),
+          )!
+        : sql`false`,
+    );
+  }
+  if (q.tvdbid) {
+    const norm = normalizeMediaId('tvdb', q.tvdbid);
+    conditions.push(norm ? eq(schema.torrents.tvdbId, norm) : sql`false`);
+  }
+  if (q.tag) {
+    const cond = await tagFilterCondition(q.tag);
+    if (cond) conditions.push(cond);
+  }
+  if (q.tagGroups) {
+    const cond = tagGroupsCondition(q.tagGroups);
+    if (cond) conditions.push(cond);
+  }
+  if (q.uploader) {
+    // « Envois anonymes » vaut aussi pour la liste des envois d'un membre : seuls
+    // lui-même et l'équipe peuvent la demander par son nom.
+    const isStaff = !!(viewer.isAdmin || viewer.isModerator);
+    conditions.push(
+      sql`${schema.torrents.uploaderId} IN (
+        SELECT u.id FROM ${schema.users} u
+         WHERE lower(u.username) = ${q.uploader.toLowerCase()}
+           AND (u.anonymous_uploads = false OR u.id = ${viewer.id} OR ${isStaff})
+      )`,
+    );
+  }
+  if (typeof q.year === 'number') {
+    // Le motif partagé, resserré sur l'année demandée (voir `YEAR_IN_NAME_RE`).
+    conditions.push(sql`${schema.torrents.name} ~ ${yearInNameRe(q.year)}`);
+  }
+  if (typeof q.season === 'number') conditions.push(eq(schema.torrents.season, q.season));
+  if (typeof q.episode === 'number') conditions.push(eq(schema.torrents.episode, q.episode));
+  if (typeof q.minSeeders === 'number' && q.minSeeders > 0) {
+    conditions.push(
+      sql`COALESCE((SELECT s.seeders FROM torrent_stats s WHERE s.info_hash = ${schema.torrents.infoHash}), 0) >= ${q.minSeeders}`,
+    );
+  }
+  if (isFlag(q.freeleech)) {
+    conditions.push(
+      and(
+        eq(schema.torrents.downloadMultiplier, 0),
+        or(isNull(schema.torrents.multipliersUntil), gt(schema.torrents.multipliersUntil, sql`now()`))!,
+      )!,
+    );
+  }
+  if (isFlag(q.notTaken)) {
+    conditions.push(
+      sql`NOT EXISTS (SELECT 1 FROM ${schema.hnrTracking} h WHERE h.user_id = ${viewer.id} AND h.torrent_id = ${schema.torrents.id} AND h.downloaded > 0)`,
+    );
+  }
+  if (isFlag(q.hideSuperseded)) conditions.push(isNull(schema.torrents.supersededById));
+  if (isFlag(q.favorites)) {
+    conditions.push(
+      sql`EXISTS (SELECT 1 FROM torrent_favorites f WHERE f.user_id = ${viewer.id} AND f.torrent_id = torrents.id)`,
+    );
+  }
+  const since = q.since ? sinceInterval(q.since) : null;
+  if (since) {
+    // L'intervalle vient d'une table fermée (clés propres, pas l'héritage d'Object), jamais de la requête.
+    conditions.push(sql`torrents.created_at >= now() - ${sql.raw(`interval '${since}'`)}`);
+  }
+  if (q.groupKey) {
+    const member = groupMemberWhere(parseGroupKey(q.groupKey));
+    const scope = q.groupScope as GroupScope | undefined;
+    conditions.push(scope && scope !== 'all' ? scopeWhere(member, scope) : member);
+  }
+  return conditions;
+}
+
+export interface SearchPredicates {
+  primary: SQL | null;
+  fuzzy: SQL | null;
+  /** Le rang plein texte des lignes, pour le tri par pertinence. */
+  rankExact: SQL | null;
+  /** Le rang approximatif (similarité de mot), quand le repli s'applique. */
+  rankFuzzy: SQL | null;
+}
+
+/**
+ * La recherche plein texte : le prédicat principal, le repli approximatif, et
+ * les rangs qui vont avec.
+ *
+ * Le champ « nom » lit aussi les TITRES D'ŒUVRES (`work_titles`) : « frieren »
+ * trouve une release que le fournisseur de métadonnées appelle « Frieren:
+ * Beyond Journey's End » même si son nom de fichier dit autre chose. Le lien
+ * passe par l'identifiant externe du torrent — nu ou préfixé pour TMDb.
+ */
+export async function searchConditions(search: string | undefined): Promise<SearchPredicates> {
+  const none: SearchPredicates = { primary: null, fuzzy: null, rankExact: null, rankFuzzy: null };
+  if (!search) return none;
+  if (/^[0-9a-fA-F]{40}$/.test(search)) {
+    return { ...none, primary: eq(schema.torrents.infoHash, search.toLowerCase()) };
+  }
+  const fields = parseSearchFields(await getSetting(SEARCH_FIELDS_SETTING));
+  const tsq = toPrefixTsQuery(search);
+  if (!tsq) return none;
+  if (!fields.length) return { ...none, primary: sql`false` };
+  const q = sql`to_tsquery(${FTS_CONFIG}, ${tsq})`;
+  const branches: SQL[] = [];
+  if (fields.includes('name')) {
+    branches.push(sql`${ftsVector(schema.torrents.name)} @@ ${q}`);
+    // Les œuvres dont le TITRE répond : cherchées d'abord dans `work_titles`
+    // (son index plein texte), puis les torrents qui les portent, par égalité
+    // sur leurs colonnes d'identifiant — indexable, et que le planificateur
+    // combine avec les deux prédicats GIN. Un EXISTS corrélé dans le OU
+    // forçait un balayage complet de `torrents` avec un sous-plan par ligne.
+    // Ordonné : sans `ORDER BY`, les 500 lignes retenues sont un sous-ensemble
+    // arbitraire que Postgres peut recomposer d'un appel à l'autre — la bande et
+    // la grille d'une même page se seraient alors contredites.
+    const works = (await db.execute(sql`
+      SELECT DISTINCT source, external_id, bare_id FROM ${schema.workTitles}
+       WHERE ${ftsVector(sql`title`)} @@ ${q}
+       ORDER BY source, external_id
+       LIMIT ${WORK_TITLE_MATCH_CAP}
+    `)) as unknown as Array<{ source: string; external_id: string; bare_id: string }>;
+    const tmdb = new Set<string>();
+    const igdb = new Set<string>();
+    const openlibrary = new Set<string>();
+    for (const w of works) {
+      if (w.source === 'tmdb') {
+        // Les formes qu'une release peut porter pour CETTE œuvre : l'identifiant
+        // tel qu'il a été cherché, et le nombre nu. Les préfixes ne sont ajoutés
+        // que si la ligne n'en porte aucun — sinon `tv/1399` allait chercher
+        // `movie/1399`, une autre œuvre qui partage le nombre.
+        tmdb.add(w.external_id);
+        tmdb.add(w.bare_id);
+        if (!w.external_id.includes('/')) {
+          tmdb.add(`tv/${w.bare_id}`);
+          tmdb.add(`movie/${w.bare_id}`);
+        }
+      } else if (w.source === 'igdb') igdb.add(w.external_id);
+      else if (w.source === 'openlibrary') openlibrary.add(w.external_id);
+    }
+    // `inArray` : une liste de paramètres, que l'index de la colonne sert (le
+    // planificateur en fait un BitmapOr avec les deux prédicats GIN).
+    if (tmdb.size) branches.push(inArray(schema.torrents.tmdbId, Array.from(tmdb)));
+    if (igdb.size) branches.push(inArray(schema.torrents.igdbId, Array.from(igdb)));
+    if (openlibrary.size) branches.push(inArray(schema.torrents.openlibraryId, Array.from(openlibrary)));
+  }
+  if (fields.includes('description')) branches.push(sql`${ftsVector(schema.torrents.description)} @@ ${q}`);
+  if (fields.includes('nfo')) branches.push(sql`${ftsVector(schema.torrents.nfo)} @@ ${q}`);
+  if (fields.includes('tags')) {
+    branches.push(sql`EXISTS (
+      SELECT 1 FROM ${schema.torrentTags} tt
+      JOIN ${schema.tags} tg ON tg.id = tt.tag_id
+      WHERE tt.torrent_id = ${schema.torrents.id}
+        AND ${ftsVector(sql`tg.name`)} @@ ${q}
+    )`);
+  }
+  const primary = branches.length > 1 ? or(...branches)! : branches[0]!;
+  const term = fuzzyTerm(search);
+  const fuzzyOn = parseSearchFuzzy(await getSetting(SEARCH_FUZZY_SETTING));
+  const fuzzy = term && fuzzyOn ? sql`${term} <% ${schema.torrents.name}` : null;
+  return {
+    primary,
+    fuzzy,
+    // `ts_rank_cd` sur le nom : le titre d'œuvre ouvre la porte, le nom classe.
+    rankExact: sql`ts_rank_cd(${ftsVector(schema.torrents.name)}, ${q})`,
+    rankFuzzy: term && fuzzyOn ? sql`word_similarity(${term}, ${schema.torrents.name})` : null,
+  };
+}
+
+/* ── L'enrichissement d'une page de lignes ─────────────────────────────────── */
+
+type Row = {
+  id: string;
+  infoHash: string;
+  uploaderId: string | null;
+  tmdbId: string | null;
+  igdbId: string | null;
+  openlibraryId: string | null;
+  downloadMultiplier: number;
+  multipliersUntil: Date | string | null;
+  torrentTags?: Array<{ tag: unknown }> | null;
+  [k: string]: unknown;
+};
+
+function workRefOf(row: Row): WorkRef | null {
+  if (row.tmdbId) return { source: 'tmdb', id: row.tmdbId };
+  if (row.igdbId) return { source: 'igdb', id: row.igdbId };
+  if (row.openlibraryId) return { source: 'openlibrary', id: row.openlibraryId };
+  return null;
+}
+
+/**
+ * Ce qu'une ligne du catalogue dit de plus qu'une ligne de la table : l'essaim
+ * vivant, si ce membre l'a en favori, s'il l'a DÉJÀ PRISE (des octets sur son
+ * suivi de seed), qui l'a envoyée, si elle est gratuite en ce moment, et l'œuvre
+ * telle que le cache la connaît. Cinq lectures pour la page, jamais par ligne.
+ */
+export async function enrichListing<T extends Row>(rows: T[], viewer: ListingViewer) {
+  if (rows.length === 0) return [] as Array<T & EnrichmentFields>;
+  const ids = rows.map((r) => r.id);
+  const uids = Array.from(new Set(rows.map((r) => r.uploaderId).filter((u): u is string => !!u)));
+  const favQ: Promise<Array<{ torrentId: string }>> = db
+    .select({ torrentId: schema.torrentFavorites.torrentId })
+    .from(schema.torrentFavorites)
+    .where(and(eq(schema.torrentFavorites.userId, viewer.id), inArray(schema.torrentFavorites.torrentId, ids)));
+  const takenQ: Promise<Array<{ torrentId: string }>> = db
+    .select({ torrentId: schema.hnrTracking.torrentId })
+    .from(schema.hnrTracking)
+    .where(
+      and(
+        eq(schema.hnrTracking.userId, viewer.id),
+        inArray(schema.hnrTracking.torrentId, ids),
+        gt(schema.hnrTracking.downloaded, 0),
+      ),
+    );
+  const uploadersQ: Promise<Array<{ id: string; username: string; anonymousUploads: boolean }>> = uids.length
+    ? db
+        .select({ id: schema.users.id, username: schema.users.username, anonymousUploads: schema.users.anonymousUploads })
+        .from(schema.users)
+        .where(inArray(schema.users.id, uids))
+    : Promise.resolve([]);
+  // L'essaim vient du collecteur (`torrent_stats`), comme les facettes et le
+  // tri : une seule lecture pour la page, et un compte « avec des seeders »
+  // qui colle aux lignes. La fiche, elle, lit l'essaim vivant.
+  const statsQ: Promise<Array<{ infoHash: string; seeders: number; leechers: number; completed: number }>> = db
+    .select({
+      infoHash: schema.torrentStats.infoHash,
+      seeders: schema.torrentStats.seeders,
+      leechers: schema.torrentStats.leechers,
+      completed: schema.torrentStats.completed,
+    })
+    .from(schema.torrentStats)
+    .where(inArray(schema.torrentStats.infoHash, rows.map((r) => r.infoHash)));
+  const [statRows, favRows, takenRows, uploaderRows, works] = await Promise.all([
+    statsQ,
+    favQ,
+    takenQ,
+    uploadersQ,
+    worksFromCache(
+      Array.from(new Map(rows.map(workRefOf).filter((w): w is WorkRef => !!w).map((w) => [workRefKey(w), w])).values()),
+      viewer.language ?? undefined,
+    ),
+  ]);
+  const statsByHash = new Map(statRows.map((r) => [r.infoHash, r]));
+  const favorited = new Set(favRows.map((r) => r.torrentId));
+  const taken = new Set(takenRows.map((r) => r.torrentId));
+  const uploaders = new Map(uploaderRows.map((u) => [u.id, u]));
+  const now = Date.now();
+  return rows.map((row) => {
+    const stats = statsByHash.get(row.infoHash) ?? { seeders: 0, leechers: 0, completed: 0 };
+    const until = row.multipliersUntil ? new Date(row.multipliersUntil).getTime() : null;
+    const ref = workRefOf(row);
+    return {
+      ...row,
+      torrentTags: undefined,
+      tags: (row.torrentTags ?? []).map((tt) => tt.tag),
+      stats: { seeders: stats.seeders, leechers: stats.leechers, completed: stats.completed },
+      viewerFavorited: favorited.has(row.id),
+      viewerTaken: taken.has(row.id),
+      // Le même voile que la fiche : un uploadeur anonyme n'a ni nom ni id ici,
+      // sauf pour lui-même et pour l'équipe (`redactUploader`).
+      ...(() => {
+        const u = row.uploaderId ? uploaders.get(row.uploaderId) : undefined;
+        const red = redactUploader(u ? { id: u.id, username: u.username, anonymousUploads: u.anonymousUploads } : null, viewer);
+        return {
+          uploaderId: red.uploaderId,
+          uploader: red.uploader ? { id: red.uploader.id, username: red.uploader.username } : null,
+          uploaderAnonymous: red.uploaderAnonymous,
+        };
+      })(),
+      freeleech: row.downloadMultiplier === 0 && (until === null || until > now),
+      work: ref ? works.get(workRefKey(ref)) ?? null : null,
+    } as T & EnrichmentFields;
+  });
+}
+
+export interface EnrichmentFields {
+  tags: unknown[];
+  stats: { seeders: number; leechers: number; completed: number };
+  viewerFavorited: boolean;
+  viewerTaken: boolean;
+  uploader: { id: string; username: string | null } | null;
+  uploaderAnonymous: boolean;
+  freeleech: boolean;
+  work: CachedWork | null;
+}
diff --git a/apps/api/utils/torrentModeration.ts b/apps/api/utils/torrentModeration.ts
index c258c661..2fdad0da 100644
--- a/apps/api/utils/torrentModeration.ts
+++ b/apps/api/utils/torrentModeration.ts
@@ -229,6 +229,8 @@ export async function transitionStatus(opts: {
       tmdbId: updated.tmdbId,
       tvdbId: updated.tvdbId,
       uploaderId: updated.uploaderId,
+      season: updated.season,
+      episode: updated.episode,
     });
 
     // The IRC announce channel, on the same edge and for the same reason: this
diff --git a/apps/api/utils/torrentSort.ts b/apps/api/utils/torrentSort.ts
index e965c804..e9abd3fd 100644
--- a/apps/api/utils/torrentSort.ts
+++ b/apps/api/utils/torrentSort.ts
@@ -32,7 +32,7 @@ function swarmColumn(column: 'seeders' | 'leechers' | 'completed'): SQL {
   return sql`(SELECT s.${sql.raw(column)} FROM torrent_stats s WHERE s.info_hash = ${schema.torrents.infoHash})`;
 }
 
-const SORT_KEYS: Record<TorrentSortKey, SQL> = {
+const SORT_KEYS: Record<Exclude<TorrentSortKey, 'relevance'>, SQL> = {
   age: availableAt,
   // Case-insensitive: otherwise every capitalised release sorts ahead of every
   // lowercase one and "A to Z" reads as nonsense.
@@ -54,12 +54,26 @@ const SORT_KEYS: Record<TorrentSortKey, SQL> = {
  * `NULLS LAST` on a descending sort keeps torrents the collector has never seen
  * at the bottom where they belong, rather than heading the list.
  */
+/** Ce que « pertinence » classe : le rang plein texte de la recherche en cours. */
+export interface SortContext {
+  rank?: SQL | null;
+}
+
 export function buildTorrentOrderBy(
   sortBy: TorrentSortKey,
-  order: SortDirection
+  order: SortDirection,
+  ctx?: SortContext
 ): SQL[] {
+  // L'identifiant ferme chaque tri : deux releases importées à la même seconde
+  // ne peuvent plus permuter entre deux pages, ni se répéter au « charger plus ».
+  const tiebreak = sql`${schema.torrents.id} DESC`;
+  if (sortBy === 'relevance') {
+    // Sans texte, la pertinence n'existe pas : c'est la nouveauté.
+    if (!ctx?.rank) return buildTorrentOrderBy('age', 'desc');
+    return [sql`${ctx.rank} DESC NULLS LAST`, sql`${availableAt} DESC`, tiebreak];
+  }
   const direction = order === 'asc' ? sql`ASC` : sql`DESC`;
   const nulls = order === 'asc' ? sql`NULLS FIRST` : sql`NULLS LAST`;
   const primary = sql`${SORT_KEYS[sortBy]} ${direction} ${nulls}`;
-  return sortBy === 'age' ? [primary] : [primary, sql`${availableAt} DESC`];
+  return sortBy === 'age' ? [primary, tiebreak] : [primary, sql`${availableAt} DESC`, tiebreak];
 }
diff --git a/apps/web/app/app.vue b/apps/web/app/app.vue
index 0e5bcff5..bb259a87 100644
--- a/apps/web/app/app.vue
+++ b/apps/web/app/app.vue
@@ -21,4 +21,23 @@
 // `data-theme` server-side. Called here rather than in the layout because the
 // login and registration pages set `layout: false`.
 useColorMode();
+
+/*
+ * La langue du document, alignée sur celle du membre.
+ *
+ * `nuxt.config` pose un plancher (`lang="en"`) pour que le HTML servi n'en soit
+ * jamais dépourvu, y compris dans la construction statique où ce fichier ne
+ * tourne pas. Ici on met la vraie : le code BCP-47 déclaré pour la locale
+ * (`en-US`, `fr-FR`), et non le code court, parce que c'est ce qu'un lecteur
+ * d'écran utilise pour choisir sa voix ET sa prononciation régionale.
+ */
+const { locale, locales } = useI18n();
+useHead({
+  htmlAttrs: {
+    lang: () =>
+      (locales.value as Array<{ code: string; language?: string }>).find(
+        (l) => l.code === locale.value,
+      )?.language || locale.value,
+  },
+});
 </script>
diff --git a/apps/web/app/assets/css/main.css b/apps/web/app/assets/css/main.css
index cdb51133..ba3b23be 100644
--- a/apps/web/app/assets/css/main.css
+++ b/apps/web/app/assets/css/main.css
@@ -382,14 +382,29 @@
     color: rgb(var(--accent-fg));
   }
 
-  /* Scrollbars — track in surface, thumb in line */
-  ::-webkit-scrollbar { @apply w-2 h-2; }
-  ::-webkit-scrollbar-track { background: rgb(var(--bg-surface)); }
-  ::-webkit-scrollbar-thumb {
-    background: rgb(var(--line-default));
-    border-radius: var(--radius-pill);
+  /* Barres de défilement.
+   *
+   * Le bloc `::-webkit-scrollbar` qui était ici faisait bien plus que colorer.
+   * Dans Chromium comme dans WebKit, styler ces pseudo-éléments bascule TOUT
+   * défilement en barre « classique » : une gouttière de 8 px prise sur la
+   * page, une piste en `--bg-surface` plus claire que le fond, et le décor
+   * d'une fiche coupé net à 8 px du bord — même sur un Mac réglé en barres
+   * flottantes, qui n'en aurait montré aucune. Mesuré sur la racine : 8 px de
+   * gouttière avec le bloc, 0 sans.
+   *
+   * Les deux propriétés standard n'ont pas cet effet. Là où le système fait
+   * flotter ses barres (macOS par défaut, iOS, Android), elles flottent : le
+   * contenu passe dessous et la barre par-dessus. Là où il les fixe (Windows,
+   * Linux, macOS « toujours »), elles sont fines, la piste transparente laisse
+   * voir le fond de la page ou de la boîte, et le pouce prend le trait fort du
+   * thème. `scrollbar-color` s'hérite, `scrollbar-width` non : d'où `*`.
+   *
+   * Pas de repli `::-webkit-scrollbar` pour les Safari d'avant 18.2 : il
+   * recréerait exactement la panne. Ils gardent la barre native, flottante. */
+  * {
+    scrollbar-width: thin;
+    scrollbar-color: rgb(var(--line-strong)) transparent;
   }
-  ::-webkit-scrollbar-thumb:hover { background: rgb(var(--line-strong)); }
 
   /* Focus ring — thin, keyboard only */
   /* One focus ring, from one token, for everything.
@@ -927,3 +942,10 @@
   }
 }
 
+/* Une page qui porte un bouton flottant (le catalogue, sous 1100 px) dégage le
+   pied de page : sinon le bouton recouvre ses liens quand on est tout en bas. */
+@media (max-width: 68.75rem) {
+  body.has-fab footer {
+    padding-bottom: calc(4.5rem + env(safe-area-inset-bottom, 0px));
+  }
+}
diff --git a/apps/web/app/assets/css/upload-form.css b/apps/web/app/assets/css/upload-form.css
index 033a9127..321d81b9 100644
--- a/apps/web/app/assets/css/upload-form.css
+++ b/apps/web/app/assets/css/upload-form.css
@@ -20,6 +20,10 @@
   margin-bottom: 2rem;
 }
 .back-link {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 15 px avant.
+     Cette règle est GLOBALE : c'est elle que rendent /torrents/upload et
+     /templates, qui écrivent `class="back-link"` sans la définir. */
+  min-height: 1.5rem;
   display: inline-flex;
   align-items: center;
   gap: 0.5rem;
@@ -97,7 +101,6 @@
      in the form column happens to scroll behind it. Without this
      the pill would blend into headings on a dark theme. */
   backdrop-filter: blur(8px);
-  -webkit-backdrop-filter: blur(8px);
   background-color: rgb(var(--bg-base) / 0.78);
   box-shadow: 0 2px 8px rgb(var(--shadow-color) / calc(0.18 * var(--shadow-strength)));
 }
diff --git a/apps/web/app/components/DescriptionRender.vue b/apps/web/app/components/DescriptionRender.vue
index ca5e1c06..44ce2d72 100644
--- a/apps/web/app/components/DescriptionRender.vue
+++ b/apps/web/app/components/DescriptionRender.vue
@@ -19,14 +19,30 @@ import { toEditorHtml } from '~/utils/editorFormats';
 
 defineOptions({ inheritAttrs: false });
 
-const props = defineProps<{
-  /** Raw description as stored in the DB (BBCode, Markdown, or
-   *  HTML — the renderer auto-detects). `null`/`undefined`/empty
-   *  produce an empty render (no warning, no fallback text). */
-  source?: string | null | undefined;
-}>();
+const props = withDefaults(
+  defineProps<{
+    /** Raw description as stored in the DB (BBCode, Markdown, or
+     *  HTML — the renderer auto-detects). `null`/`undefined`/empty
+     *  produce an empty render (no warning, no fallback text). */
+    source?: string | null | undefined;
+    /**
+     * De combien de niveaux descendre les titres du contenu. Sur la fiche, la
+     * note vit sous un `<h2>` ; un `# Titre` d'uploadeur rendu en `<h1>` y
+     * posait un second h1 dans la page (mesuré sur Re:ZERO : h1, h2, h2, h3…
+     * dans la note). Avec 2, h1 → h3 et la hiérarchie reste celle de la page.
+     */
+    headingOffset?: number;
+  }>(),
+  { source: null, headingOffset: 0 },
+);
 
-const rendered = computed(() => toEditorHtml(props.source));
+const rendered = computed(() => {
+  const html = toEditorHtml(props.source);
+  const off = Math.max(0, Math.min(5, Math.trunc(props.headingOffset)));
+  if (!off) return html;
+  // Sortie déjà assainie par DOMPurify : balises normalisées, remplacement sûr.
+  return html.replace(/<(\/?)h([1-6])\b/gi, (_m, slash: string, n: string) => `<${slash}h${Math.min(6, Number(n) + off)}`);
+});
 </script>
 
 <style scoped>
@@ -34,6 +50,10 @@ const rendered = computed(() => toEditorHtml(props.source));
   color: rgb(var(--fg-default));
   font-size: 0.875rem;
   line-height: 1.65;
+  /* Une note contient des noms de release — 104 caractères sans espace, mesuré
+     sur une fiche importée. Sans point de coupe, le paragraphe garde sa largeur
+     mais son texte déborde de la colonne et la PAGE défile de 322 px à 375. */
+  overflow-wrap: anywhere;
 }
 </style>
 
@@ -106,7 +126,10 @@ const rendered = computed(() => toEditorHtml(props.source));
 }
 .description-render h1 { font-size: 1.4rem; }
 .description-render h2 { font-size: 1.25rem; }
-.description-render h3 { font-size: 1.1rem; }
+.description-render h3 { font-size: 1.15rem; }
+.description-render h4 { font-size: 1.05rem; }
+.description-render h5 { font-size: 1rem; }
+.description-render h6 { font-size: 0.9375rem; }
 
 /* Images — keep them inline-block so the parent's
    `text-align: center` (from `[center]` blocks) actually centres
diff --git a/apps/web/app/components/GameMetadataCard.vue b/apps/web/app/components/GameMetadataCard.vue
index 22a7f805..462eb34c 100644
--- a/apps/web/app/components/GameMetadataCard.vue
+++ b/apps/web/app/components/GameMetadataCard.vue
@@ -475,7 +475,7 @@ function formatReleaseDate(iso: string | null): string {
 .gcard-shots-label { margin-bottom: 0.1rem; }
 .gcard-shots-track {
   display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
+  grid-template-columns: repeat(auto-fill, minmax(min(100%, 180px), 1fr));
   gap: 0.55rem;
 }
 .gcard-shot {
diff --git a/apps/web/app/components/IconPicker.vue b/apps/web/app/components/IconPicker.vue
index 51c28fb0..76ea44ba 100644
--- a/apps/web/app/components/IconPicker.vue
+++ b/apps/web/app/components/IconPicker.vue
@@ -469,21 +469,13 @@ onBeforeUnmount(() => {
   margin: 0;
   padding: 0;
   display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(64px, 1fr));
+  grid-template-columns: repeat(auto-fill, minmax(min(100%, 64px), 1fr));
   gap: 0.4rem;
   overflow-y: auto;
   max-height: 15rem;
   scrollbar-width: thin;
   scrollbar-color: rgb(var(--line-strong)) transparent;
 }
-.icon-picker-grid::-webkit-scrollbar {
-  width: 8px;
-}
-.icon-picker-grid::-webkit-scrollbar-thumb {
-  background: rgb(var(--line-strong));
-  border-radius: var(--radius-sm);
-}
-
 .icon-picker-cell {
   display: flex;
   flex-direction: column;
diff --git a/apps/web/app/components/MediaMetadataCard.vue b/apps/web/app/components/MediaMetadataCard.vue
index a08d0409..069d2db9 100644
--- a/apps/web/app/components/MediaMetadataCard.vue
+++ b/apps/web/app/components/MediaMetadataCard.vue
@@ -350,6 +350,8 @@ function formatRuntime(minutes: number): string {
   flex-wrap: wrap;
 }
 .media-card-link {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 17 px avant. */
+  min-height: 1.5rem;
   display: inline-flex;
   align-items: center;
   gap: 0.375rem;
diff --git a/apps/web/app/components/NotificationBell.vue b/apps/web/app/components/NotificationBell.vue
index 56bd144d..e76d5108 100644
--- a/apps/web/app/components/NotificationBell.vue
+++ b/apps/web/app/components/NotificationBell.vue
@@ -362,15 +362,17 @@ function humanise(s: string): string {
   display: inline-flex;
   align-items: center;
   justify-content: center;
-  background: #f43f5e;
-  color: rgb(var(--danger-fg));  /* jeton sémantique : cette teinte était figée sur le thème sombre */
+  /* Le jeton, pas un rose figé : `#f43f5e` sous le blanc de `--danger-fg`
+     tombait à 3,67:1 en thème clair. `--danger` y est plus sombre, 6,4:1. */
+  background: rgb(var(--danger));
+  color: rgb(var(--danger-fg));
   border-radius: var(--radius-pill);
   font-family: var(--font-mono);
   font-size: 0.5625rem;
   font-weight: 800;
   letter-spacing: calc(0.02em * var(--tracking-scale));
   border: 2px solid rgb(var(--bg-base));
-  box-shadow: 0 0 0 1px rgba(244, 63, 94, 0.45);
+  box-shadow: 0 0 0 1px rgb(var(--danger) / 0.45);
 }
 
 /* ── Popover ────────────────────────────────────────────── */
@@ -602,11 +604,10 @@ function humanise(s: string): string {
   max-height: 26rem;
   overflow-y: auto;
 }
-.nbell-list::-webkit-scrollbar { width: 6px; }
-.nbell-list::-webkit-scrollbar-thumb {
-  background: rgb(var(--accent-warm) / 0.25);
-  border-radius: var(--radius-md);
-}
+/* Le pouce dans la teinte de la cloche. Propriétés standard seulement : un
+   `::-webkit-scrollbar` figeait ici une barre classique de 6 px même sur un
+   système à barres flottantes (voir main.css). */
+.nbell-list { scrollbar-color: rgb(var(--accent-warm) / 0.35) transparent; }
 
 .nbell-row:focus-visible {
   outline: 2px solid rgb(var(--focus-ring));
diff --git a/apps/web/app/components/ReportModal.vue b/apps/web/app/components/ReportModal.vue
index 11e22ecc..5fd83172 100644
--- a/apps/web/app/components/ReportModal.vue
+++ b/apps/web/app/components/ReportModal.vue
@@ -176,6 +176,13 @@ const props = defineProps<{
   targetLabel?: string;
   /** Optional warning shown above the actions, before submitting. */
   caveat?: string;
+  /**
+   * Un motif déjà choisi à l'ouverture — la valeur d'une des options, telle
+   * que l'API la reçoit. Posé par les entrées qui savent déjà de quoi elles
+   * parlent (« Mauvaise fiche ? » sur la fiche d'un torrent) : le membre n'a
+   * plus qu'à décrire, et le modérateur reçoit un signalement déjà qualifié.
+   */
+  presetReason?: string | null;
 }>();
 
 const emit = defineEmits<{
@@ -234,6 +241,11 @@ const reasonOptions = computed(() => [
     label: t('components.report.reasons.harassment'),
     icon: 'ph:hand-palm-bold',
   },
+  {
+    value: t('components.report.reasons.wrongMetadata'),
+    label: t('components.report.reasons.wrongMetadataShort'),
+    icon: 'ph:film-slate-bold',
+  },
   {
     value: t('components.report.reasons.other'),
     label: t('components.report.reasons.otherShort'),
@@ -241,6 +253,15 @@ const reasonOptions = computed(() => [
   },
 ]);
 
+// Le motif prérempli s'applique à CHAQUE ouverture, pas seulement au montage :
+// la même boîte sert au signalement général et à « Mauvaise fiche ? ».
+watch(
+  () => props.isOpen,
+  (open) => {
+    if (open && props.presetReason) reason.value = props.presetReason;
+  },
+);
+
 function close() {
   reason.value = '';
   details.value = '';
diff --git a/apps/web/app/components/SectionHead.vue b/apps/web/app/components/SectionHead.vue
new file mode 100644
index 00000000..f6f4f6c9
--- /dev/null
+++ b/apps/web/app/components/SectionHead.vue
@@ -0,0 +1,262 @@
+<script setup lang="ts">
+/**
+ * Le titre d'une section, une fois pour toutes.
+ *
+ * Le motif `.section-head / -mark / -title / -line / -count` était recopié en
+ * CSS scopé dans **treize** fichiers de pages et défini zéro fois dans
+ * `main.css`. Treize copies d'un même bloc dérivent : elles l'ont déjà fait sur
+ * la marge basse et sur la graisse du filet.
+ *
+ * Ce composant ne migre pas les treize — ce serait un autre chantier, avec son
+ * propre rayon d'impact. Il existe pour que la page de détail d'un torrent, qui
+ * en portait la plus grosse copie, cesse d'en être une quatorzième, et pour que
+ * les composants extraits de cette page n'aient pas chacun à redéfinir le
+ * motif. C'est précisément le piège dans lequel `.tool-btn` est tombée ici :
+ * une classe utilisée par cinq fichiers et définie dans deux.
+ *
+ * # `--section-tone` : la teinte de la famille, héritée et non passée en prop
+ *
+ * Le recensement des couleurs de la fiche a mesuré 284 instances d'élément
+ * colorées sur 348 en gris pur (82 %) : treize sections avec un conteneur
+ * identique, et rien pour dire au lecteur laquelle est la fiche technique et
+ * laquelle est la zone d'exploitation. La teinte est donc portée par une
+ * propriété personnalisée que les composants posent sur LEUR racine, et que
+ * cette en-tête lit.
+ *
+ * Héritée plutôt que passée en prop, pour deux raisons :
+ *   - Une propriété personnalisée traverse la frontière du `<style scoped>` de
+ *     Vue (le scopage agit sur les sélecteurs, pas sur la cascade des
+ *     variables), donc un ancêtre suffit et aucun gabarit appelant ne change.
+ *   - Le repli `var(--section-tone, var(--accent-warm))` garde exactement
+ *     l'apparence d'avant pour les appelants qui ne posent rien — dont deux
+ *     fichiers en cours de refonte par ailleurs.
+ *
+ * La teinte ne touche QUE des éléments non textuels : le glyphe de l'icône, le
+ * filet, et la bordure de la pastille. Mesuré : `--accent-warm` sur fond neutre
+ * donne 3,05:1 au pire (thème clair, `--bg-hover`) — au-dessus des 3:1 que
+ * WCAG 1.4.11 demande d'un élément non textuel, et sous les 4,5:1 d'un texte,
+ * ce qui est exactement pourquoi elle n'en peint aucun. Le texte de la pastille
+ * reste `--fg-muted` sur le voile à 12 % : 5,94:1 au pire des huit teintes et
+ * des deux thèmes.
+ */
+withDefaults(
+  defineProps<{
+    /** Le titre. Déjà traduit par l'appelant — ce composant ne connaît pas de clés. */
+    title: string;
+    /** Un compte affiché en pastille, quand il y en a un à donner. */
+    count?: number | null;
+    /** Icône Phosphor, à gauche du titre. */
+    icon?: string | null;
+    /** `h2` par défaut ; `h3` pour une sous-section. */
+    level?: 'h2' | 'h3';
+    /** Resserre les marges, pour une section imbriquée. */
+    compact?: boolean;
+    /**
+     * Supprime la séparation SOUS le titre.
+     *
+     * La marge basse de l'en-tête sépare le titre de son contenu. Quand ce
+     * contenu est replié, elle ne sépare plus rien : elle laisse une bande
+     * vide au bas du panneau, et le titre paraît collé en haut d'une boîte
+     * trop grande. Mesuré sur le panneau NFO fermé : 54 px de panneau pour un
+     * en-tête de 34, dont 17,6 de marge morte.
+     */
+    flush?: boolean;
+  }>(),
+  { count: null, icon: null, level: 'h2', compact: false, flush: false },
+);
+</script>
+
+<template>
+  <div
+    class="section-head"
+    :class="{ 'section-head--compact': compact, 'section-head--flush': flush }"
+  >
+    <span v-if="icon" class="section-head-plate" aria-hidden="true">
+      <Icon :name="icon" class="section-head-mark" />
+    </span>
+    <component :is="level" class="section-head-title">{{ title }}</component>
+    <!-- Le compte AVANT le filet : il appartient au titre, pas à la décoration.
+         C'est ce qui rend « Fichiers (12) » lisible d'un coup d'œil et évite
+         d'ouvrir un repli pour savoir s'il valait le clic. -->
+    <span v-if="count !== null" class="section-head-count">{{ count }}</span>
+    <span class="section-head-line" aria-hidden="true" />
+    <!-- L'action de droite : le bouton « copier » d'un NFO, un lien « tout voir ». -->
+    <slot name="action" />
+  </div>
+</template>
+
+<style scoped>
+.section-head {
+  /* Le repli EST la valeur d'avant : un appelant qui ne pose rien ne change
+     pas d'apparence. */
+  /*
+   * `--section-tint` AUSSI, parce que c'est le nom que le reste du site
+   * emploie déjà : `me.vue` peint son filet de section avec, bien avant que
+   * cette page n'invente `--section-tone` pour la même idée. Accepter les deux
+   * évite qu'une troisième page en invente un troisième.
+   */
+  --tone: var(--section-tone, var(--section-tint, var(--accent-warm)));
+  display: flex;
+  /*
+   * Le repli, sans quoi l'action de fin de ligne SORT de l'en-tête.
+   *
+   * Mesuré sur la fiche d'un torrent à 320 px de large : « Toutes les
+   * releases → » fait 158 px, l'en-tête n'en offre que 269 une fois le titre
+   * posé, et le lien s'étendait jusqu'à x=390 dans une fenêtre de 367 — 78 px
+   * de défilement horizontal pour la page entière. Même chose avec l'indice
+   * du NFO (125 px) et l'étiquette d'essaim (126 px) : trois symptômes, un
+   * seul en-tête. Au-dessus de 430 px rien ne se voyait.
+   */
+  flex-wrap: wrap;
+  align-items: center;
+  /*
+   * `0.75rem` et `padding-bottom: 0.4rem` : les valeurs de `.section-head`
+   * dans `me.vue`, qui est la page la plus travaillée du site et donc la
+   * référence de fait. Deux en-têtes qui veulent dire la même chose et ne se
+   * ressemblent pas tout à fait se lisent comme une négligence, pas comme une
+   * intention.
+   */
+  gap: 0.75rem;
+  margin-bottom: 1.1rem;
+  padding-bottom: 0.4rem;
+}
+.section-head--compact {
+  margin-bottom: 0.6rem;
+}
+/* Rien à séparer : le contenu est replié. */
+.section-head--flush {
+  margin-bottom: 0;
+  padding-bottom: 0;
+}
+
+/* ── La marque : une plaque NEUTRE, jamais teintée ────────────────────────
+   Le glyphe est de la teinte ; sa plaque ne peut donc pas l'être. Mesuré :
+   une teinte posée sur un voile de 8 % d'ELLE-MÊME tombe à 2,59:1 en thème
+   clair pour l'or et 2,79:1 pour `--chart-1` — sous les 3:1 d'un élément non
+   textuel. C'est le même défaut que la note de `main.css` décrit pour le
+   texte, et il vaut aussi pour une icône. Fond neutre, teinte sur le glyphe et
+   sur le filet : la paire tient dans les deux thèmes. */
+.section-head-plate {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex: none;
+  width: 1.6rem;
+  height: 1.6rem;
+  background: rgb(var(--bg-inset));
+  border: 1px solid rgb(var(--tone) / 0.45);
+  border-radius: var(--radius-sm);
+  transition:
+    border-color var(--dur-3) var(--ease-standard),
+    background-color var(--dur-3) var(--ease-standard);
+}
+.section-head--compact .section-head-plate {
+  width: 1.35rem;
+  height: 1.35rem;
+  border-radius: var(--radius-xs);
+}
+.section-head-mark {
+  font-size: 0.9rem;
+  color: rgb(var(--tone));
+}
+.section-head--compact .section-head-mark {
+  font-size: 0.78125rem;
+}
+
+/* ── Le titre ─────────────────────────────────────────────────────────────
+   La police d'affichage n'apparaissait que 9 fois sur 234 nœuds de texte de la
+   fiche (3,8 %), parce que la variante `compact` — celle que portent onze des
+   treize sections — la remplaçait par de l'Inter capitale grise. La signature
+   typographique du site était donc absente de sa page la plus dense.
+   Les deux variantes prennent maintenant Fraunces, et se distinguent par le
+   STYLE plutôt que par la police : italique pour une section, romain pour une
+   sous-section. C'est la distinction qu'un titre de niveau porte en édition,
+   et elle survit à un changement de police par l'exploitant. */
+.section-head-title {
+  margin: 0;
+  font-family: var(--font-display);
+  font-style: italic;
+  font-weight: 500;
+  /* `rem` et non `px` : `--ui-scale` n'est appliqué qu'une seule fois, sur
+     `html { font-size }`, donc toute taille en pixels rend le réglage
+     d'échelle de l'exploitant inerte. */
+  font-size: clamp(1.15rem, 2.2vw, 1.55rem);
+  line-height: 1.15;
+  letter-spacing: calc(-0.015em * var(--tracking-scale));
+  color: rgb(var(--fg-strong));
+  white-space: nowrap;
+}
+/*
+ * `compact` change la TAILLE, plus la langue.
+ *
+ * Il basculait en romain non-display : sur une même page, « Versions » et
+ * « Commentaires » s'affichaient en italique display pendant que « NFO »,
+ * « Pistes audio », « Sous-titres » et « Note de l'uploadeur » s'affichaient
+ * en Inter droit — mesuré à 25,6 px italique contre 19,2 px romain, pour des
+ * sections qui sont exactement du même rang. Deux systèmes typographiques sur
+ * un seul écran, sans qu'aucune règle ne dise lequel s'applique quand.
+ *
+ * Il reste utile pour un titre IMBRIQUÉ (celui de la carte de décision), où
+ * une taille moindre marque la subordination — ce qu'une variation d'échelle
+ * dit très bien sans changer de police.
+ */
+.section-head--compact .section-head-title {
+  font-size: clamp(1rem, 1.6vw, 1.2rem);
+}
+
+/* ── La pastille de compte ────────────────────────────────────────────────
+   Voile de la teinte à 12 %, encre NEUTRE. C'est le seul motif teinté que le
+   contraste autorise partout : `--fg-muted` sur un voile à 12 % de n'importe
+   laquelle des huit teintes, sur n'importe laquelle des cinq surfaces, dans
+   les deux thèmes, ne descend pas sous 5,94:1. La note d'origine écartait le
+   voile parce qu'elle mesurait la teinte SUR SON PROPRE voile — le cas qui
+   échoue — et non une encre neutre dessus. */
+.section-head-count {
+  flex: none;
+  min-width: 1.5rem;
+  padding: 0.05rem 0.4rem;
+  border-radius: var(--radius-pill);
+  background: rgb(var(--tone) / 0.12);
+  border: 1px solid rgb(var(--tone) / 0.35);
+  font-family: var(--font-mono);
+  font-size: 0.7rem;
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+  text-align: center;
+  color: rgb(var(--fg-muted));
+}
+
+/* ── Le filet ─────────────────────────────────────────────────────────────
+   Il partait du gris de filet et s'éteignait. Il part maintenant de la teinte,
+   passe par le gris, puis s'éteint : une trace colorée traverse la largeur de
+   CHAQUE section, ce qui est la manière la moins coûteuse de rendre la teinte
+   d'une famille visible sans peindre un seul fond. Purement décoratif —
+   `aria-hidden`, et aucune information n'y repose. */
+.section-head-line {
+  flex: 1 1 auto;
+  height: 1px;
+  min-width: 1rem;
+  background: linear-gradient(
+    to right,
+    rgb(var(--tone) / 0.65),
+    rgb(var(--line-default)) 8rem,
+    rgb(var(--line-default) / 0)
+  );
+}
+.section-head--compact .section-head-line {
+  background: linear-gradient(
+    to right,
+    rgb(var(--tone) / 0.45),
+    rgb(var(--line-default)) 5rem,
+    rgb(var(--line-default) / 0)
+  );
+}
+
+@media (max-width: 640px) {
+  .section-head-title {
+    /* Le titre passe avant le filet quand la place manque : c'est lui qu'on
+       lit, et un `nowrap` sur une largeur de téléphone le fait déborder. */
+    white-space: normal;
+  }
+}
+</style>
diff --git a/apps/web/app/components/admin/Branding.vue b/apps/web/app/components/admin/Branding.vue
index 12e0b56a..cb4aadb2 100644
--- a/apps/web/app/components/admin/Branding.vue
+++ b/apps/web/app/components/admin/Branding.vue
@@ -989,14 +989,10 @@ async function discard() {
     align-self: flex-start;
     max-height: calc(100vh - 2.5rem);
     overflow-y: auto;
-    /* Hide scrollbar for cleanliness; sample stack should fit
-       most viewports anyway. */
+    /* Fine et dans la teinte de la marque ; la pile d'exemples tient dans la
+       plupart des fenêtres. Propriétés standard seulement (voir main.css). */
     scrollbar-width: thin;
-  }
-  .adm-preview::-webkit-scrollbar { width: 4px; }
-  .adm-preview::-webkit-scrollbar-thumb {
-    background: rgb(var(--accent-warm) / 0.25);
-    border-radius: var(--radius-sm);
+    scrollbar-color: rgb(var(--accent-warm) / 0.35) transparent;
   }
 }
 
@@ -1515,6 +1511,9 @@ async function discard() {
 /* ── Logo segments + icon picker ───────────────────────────── */
 .segments {
   display: inline-flex;
+  /* Un contrôle segmenté n'est pas un titre : sur un téléphone il
+     s'enroule au lieu de pousser la page hors du cadre. */
+  flex-wrap: wrap;
   border: 1px solid rgb(var(--line-default));
   border-radius: var(--radius-sm);
   background: rgb(var(--bg-elevated));
diff --git a/apps/web/app/components/admin/Categories.vue b/apps/web/app/components/admin/Categories.vue
index 21a490a0..8cf6f533 100644
--- a/apps/web/app/components/admin/Categories.vue
+++ b/apps/web/app/components/admin/Categories.vue
@@ -16,6 +16,27 @@
     time and auto-expands any parent whose subcategory matches.
   -->
   <div class="adm">
+    <div v-if="mergeSource" class="card mb-4">
+      <div class="card-body flex flex-wrap items-center gap-3">
+        <span class="text-sm text-text-primary">
+          {{ $t('admin.categories.merge.into', { from: mergeSource.name }) }}
+        </span>
+        <select
+          v-model="mergeInto"
+          class="rounded-md border border-border bg-bg-secondary px-2 py-1.5 text-sm text-text-primary"
+          :aria-label="$t('admin.categories.merge.title')"
+        >
+          <option value="" disabled>—</option>
+          <option v-for="target in mergeTargets" :key="target.id" :value="target.id">{{ target.parentId ? '↳ ' : '' }}{{ target.name }}</option>
+        </select>
+        <button type="button" class="btn btn-primary" :disabled="!mergeInto || merging" @click="confirmMerge">
+          {{ $t('admin.categories.merge.action') }}
+        </button>
+        <button type="button" class="btn btn-secondary" @click="mergeSource = null">
+          {{ $t('admin.categories.merge.cancel') }}
+        </button>
+      </div>
+    </div>
     <!-- ── Header ───────────────────────────────────────────── -->
     <header class="atlas-head">
       <div class="atlas-head-id">
@@ -238,6 +259,15 @@
             >
               <Icon name="ph:trash-bold" />
             </button>
+            <button
+              type="button"
+              class="tool-btn"
+              :aria-label="$t('admin.categories.merge.action')"
+              :title="$t('admin.categories.merge.hint')"
+              @click="startMerge(category)"
+            >
+              <Icon name="ph:arrows-merge-bold" />
+            </button>
           </div>
         </div>
 
@@ -306,6 +336,15 @@
                   >
                     <Icon name="ph:trash-bold" />
                   </button>
+            <button
+              type="button"
+              class="tool-btn"
+              :aria-label="$t('admin.categories.merge.action')"
+              :title="$t('admin.categories.merge.hint')"
+              @click="startMerge(sub)"
+            >
+              <Icon name="ph:arrows-merge-bold" />
+            </button>
                 </div>
               </div>
             </li>
@@ -639,6 +678,56 @@ const notifications = useNotificationStore();
 const confirm = useConfirm();
 
 const expandedCategories = ref(new Set<string>());
+
+/*
+ * Fusionner : tout ce qui pointe la source pointe la cible, la source
+ * disparaît. Un import laisse « Films » et « Movies » ; c'est le geste qui les
+ * réunit. La cible ne peut être ni la source ni l'un de ses enfants.
+ */
+const mergeSource = ref<Category | null>(null);
+const mergeInto = ref('');
+const merging = ref(false);
+function startMerge(cat: Category) {
+  mergeSource.value = cat;
+  mergeInto.value = '';
+}
+const mergeTargets = computed<Category[]>(() => {
+  const src = mergeSource.value;
+  if (!src) return [];
+  const excluded = new Set([src.id, ...(src.subcategories ?? []).map((s) => s.id)]);
+  const out: Category[] = [];
+  for (const cat of categories.value ?? []) {
+    if (!excluded.has(cat.id)) out.push(cat);
+    for (const sub of cat.subcategories ?? []) if (!excluded.has(sub.id)) out.push(sub);
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+});
+async function confirmMerge() {
+  const src = mergeSource.value;
+  if (!src || !mergeInto.value || merging.value) return;
+  const target = mergeTargets.value.find((x) => x.id === mergeInto.value);
+  const ok = await confirm({
+    title: t('admin.categories.merge.title'),
+    message: t('admin.categories.merge.confirm', { from: src.name, into: target?.name ?? '' }),
+    confirmText: t('admin.categories.merge.action'),
+    destructive: true,
+  });
+  if (!ok) return;
+  merging.value = true;
+  try {
+    const res = await $fetch<{ moved: number }>(`/api/admin/categories/${src.id}/merge`, {
+      method: 'POST',
+      body: { into: mergeInto.value },
+    });
+    notifications.success(t('admin.categories.merge.done', { n: res.moved, into: target?.name ?? '' }));
+    mergeSource.value = null;
+    await refresh();
+  } catch (err: any) {
+    notifications.error(err?.data?.message || t('admin.categories.merge.failed'));
+  } finally {
+    merging.value = false;
+  }
+}
 function toggleCategory(id: string) {
   if (expandedCategories.value.has(id)) {
     expandedCategories.value.delete(id);
diff --git a/apps/web/app/components/admin/FederationHealth.vue b/apps/web/app/components/admin/FederationHealth.vue
index ba02cdb1..c2464516 100644
--- a/apps/web/app/components/admin/FederationHealth.vue
+++ b/apps/web/app/components/admin/FederationHealth.vue
@@ -451,7 +451,7 @@ function hostOf(url: string): string {
 .fh-tiles {
   display: grid;
   gap: 0.6rem;
-  grid-template-columns: repeat(auto-fit, minmax(7rem, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 7rem), 1fr));
 }
 .fh-tile {
   --tone: var(--fg-default);
diff --git a/apps/web/app/components/admin/HnrSettings.vue b/apps/web/app/components/admin/HnrSettings.vue
new file mode 100644
index 00000000..49221b33
--- /dev/null
+++ b/apps/web/app/components/admin/HnrSettings.vue
@@ -0,0 +1,167 @@
+<template>
+  <!--
+    Hit & Run : les trois réglages que le tracker et l'API lisaient déjà en
+    base sans qu'aucune interface ne les expose. Le seuil de 24 h par défaut
+    s'affichait sur chaque fiche de torrent (« vous engage à 24 h de partage »)
+    sans qu'un exploitant puisse le changer autrement qu'en SQL.
+
+      * activé — sans lui, aucune ligne n'est créée et rien n'est jamais signalé ;
+      * seuil de partage (heures) — le temps de seed exigé par release ;
+        figé sur chaque ligne à sa création, donc le changer ne rejuge pas
+        les téléchargements passés ;
+      * délai de grâce (heures) — le temps laissé après le téléchargement
+        avant qu'une release non partagée assez longtemps soit signalée.
+  -->
+  <div class="card">
+    <div class="card-header">
+      <div class="flex items-center gap-2">
+        <Icon name="ph:hourglass-medium-bold" class="text-text-muted" />
+        <h3 class="text-xs font-bold uppercase tracking-wider text-text-primary">
+          {{ $t('admin.hnrSettings.title') }}
+        </h3>
+      </div>
+    </div>
+    <div class="card-body space-y-6">
+      <p class="text-xs text-text-muted leading-relaxed">
+        {{ $t('admin.hnrSettings.description') }}
+      </p>
+
+      <div class="space-y-5">
+        <SettingsGroup
+          :control-id="fid('hnrEnabled')"
+          :label="$t('admin.hnrSettings.enabled')"
+          :description="$t('admin.hnrSettings.enabledHint')"
+        >
+          <label class="hnr-toggle" :for="fid('hnrEnabled')">
+            <input :id="fid('hnrEnabled')" v-model="enabled" type="checkbox" class="hnr-toggle-box" />
+            <span>{{ enabled ? $t('admin.hnrSettings.on') : $t('admin.hnrSettings.off') }}</span>
+          </label>
+        </SettingsGroup>
+
+        <SettingsGroup
+          :control-id="fid('requiredHours')"
+          :label="$t('admin.hnrSettings.requiredHours')"
+          :description="$t('admin.hnrSettings.requiredHint')"
+        >
+          <div class="flex items-center gap-3">
+            <input
+              :id="fid('requiredHours')"
+              v-model.number="requiredHours"
+              type="number"
+              min="0"
+              max="8760"
+              :disabled="!enabled"
+              class="w-full md:w-32 bg-bg-tertiary border border-border rounded px-3 py-2 text-sm text-text-primary focus:border-fg-default/20 font-mono disabled:opacity-50"
+            />
+            <span class="text-xs text-text-muted">{{ $t('admin.hnrSettings.hoursLabel') }}</span>
+          </div>
+        </SettingsGroup>
+
+        <SettingsGroup
+          :control-id="fid('graceHours')"
+          :label="$t('admin.hnrSettings.graceHours')"
+          :description="$t('admin.hnrSettings.graceHint')"
+        >
+          <div class="flex items-center gap-3">
+            <input
+              :id="fid('graceHours')"
+              v-model.number="graceHours"
+              type="number"
+              min="0"
+              max="8760"
+              :disabled="!enabled"
+              class="w-full md:w-32 bg-bg-tertiary border border-border rounded px-3 py-2 text-sm text-text-primary focus:border-fg-default/20 font-mono disabled:opacity-50"
+            />
+            <span class="text-xs text-text-muted">{{ $t('admin.hnrSettings.hoursLabel') }}</span>
+          </div>
+        </SettingsGroup>
+      </div>
+
+      <button
+        type="button"
+        :disabled="loading || saved"
+        class="w-full text-[10px] font-bold uppercase tracking-widest py-2.5 rounded transition-all disabled:opacity-50 flex items-center justify-center gap-2"
+        :class="saved ? 'bg-success/20 text-success' : 'bg-fg-default/10 text-text-primary hover:bg-fg-default/15'"
+        @click="save"
+      >
+        <Icon :name="saved ? 'ph:check-bold' : 'ph:floppy-disk-bold'" />
+        {{ saved ? $t('admin.hnrSettings.saved') : $t('admin.hnrSettings.save') }}
+      </button>
+      <p v-if="saveError" class="text-xs text-danger" role="alert">{{ saveError }}</p>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+const fid = useFieldIds();
+const enabled = ref(false);
+const requiredHours = ref(24);
+const graceHours = ref(72);
+const loading = ref(false);
+const saved = ref(false);
+
+const { data } = await useFetch<{
+  hnrEnabled?: boolean;
+  hnrRequiredSeedHours?: number;
+  hnrGraceHours?: number;
+}>('/api/admin/settings');
+
+watch(
+  data,
+  (v) => {
+    if (typeof v?.hnrEnabled === 'boolean') enabled.value = v.hnrEnabled;
+    if (typeof v?.hnrRequiredSeedHours === 'number') requiredHours.value = v.hnrRequiredSeedHours;
+    if (typeof v?.hnrGraceHours === 'number') graceHours.value = v.hnrGraceHours;
+  },
+  { immediate: true },
+);
+
+/** Un entier d'heures entre 0 et un an ; le serveur reborne de son côté. */
+function clampHours(n: number, fallback: number): number {
+  if (!Number.isFinite(n)) return fallback;
+  return Math.max(0, Math.min(8760, Math.floor(n)));
+}
+
+const saveError = ref<string | null>(null);
+async function save() {
+  loading.value = true;
+  saved.value = false;
+  try {
+    await $fetch('/api/admin/settings', {
+      method: 'PUT',
+      body: {
+        hnrEnabled: enabled.value,
+        hnrRequiredSeedHours: clampHours(requiredHours.value, 24),
+        hnrGraceHours: clampHours(graceHours.value, 72),
+      },
+    });
+    saved.value = true;
+    saveError.value = null;
+    setTimeout(() => (saved.value = false), 2000);
+  } catch (err) {
+    // Sans cela, un 4xx/5xx partait en rejet non géré et l'écran ne bougeait pas.
+    saveError.value = (err as { data?: { message?: string }; message?: string }).data?.message ?? (err as Error).message ?? 'error';
+  } finally {
+    loading.value = false;
+  }
+}
+</script>
+
+<style scoped>
+.hnr-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+  min-height: 2rem;
+  font-size: 0.8125rem;
+  color: rgb(var(--fg-default));
+  cursor: pointer;
+}
+.hnr-toggle-box {
+  width: 1.1rem;
+  height: 1.1rem;
+  margin: 0;
+  accent-color: rgb(var(--accent-warm));
+  cursor: pointer;
+}
+</style>
diff --git a/apps/web/app/components/admin/Invites.vue b/apps/web/app/components/admin/Invites.vue
index 80cf80e5..d1eb1a67 100644
--- a/apps/web/app/components/admin/Invites.vue
+++ b/apps/web/app/components/admin/Invites.vue
@@ -1078,6 +1078,9 @@ async function confirmDelete() {
 
 .ledger-segments {
   display: inline-flex;
+  /* Un contrôle segmenté n'est pas un titre : sur un téléphone il
+     s'enroule au lieu de pousser la page hors du cadre. */
+  flex-wrap: wrap;
   background: rgb(var(--bg-elevated));
   border: 1px solid rgb(var(--line-default));
   border-radius: var(--radius-sm);
diff --git a/apps/web/app/components/admin/PendingTorrents.vue b/apps/web/app/components/admin/PendingTorrents.vue
index f9738523..eed7bb5a 100644
--- a/apps/web/app/components/admin/PendingTorrents.vue
+++ b/apps/web/app/components/admin/PendingTorrents.vue
@@ -238,6 +238,9 @@ function formatDate(iso: string): string {
 /* ── Segmented filter ─────────────────────────────────── */
 .queue-segments {
   display: inline-flex;
+  /* Un contrôle segmenté n'est pas un titre : sur un téléphone il
+     s'enroule au lieu de pousser la page hors du cadre. */
+  flex-wrap: wrap;
   gap: 4px;
   padding: 4px;
   background: rgb(var(--bg-elevated));
@@ -452,6 +455,8 @@ function formatDate(iso: string): string {
 }
 .queue-meta-soft { color: rgb(var(--fg-subtle)); }
 .queue-link {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 15 px avant. */
+  padding-block: 0.35rem;
   color: rgb(var(--r));
   text-decoration: none;
   border-bottom: 1px solid rgb(var(--r) / 0.4);
diff --git a/apps/web/app/components/admin/SearchMisses.vue b/apps/web/app/components/admin/SearchMisses.vue
new file mode 100644
index 00000000..b8e9735e
--- /dev/null
+++ b/apps/web/app/components/admin/SearchMisses.vue
@@ -0,0 +1,137 @@
+<script setup lang="ts">
+/**
+ * Ce que les membres cherchent sans rien trouver.
+ *
+ * La meilleure liste d'acquisition possible : ce qui manque, avec la
+ * fréquence. Une ligne traitée (la release est arrivée, ou n'existe pas)
+ * s'efface ; « Créer une demande » ouvre le formulaire des demandes.
+ */
+import { formatAgo } from '~/utils/format';
+
+interface Miss {
+  query: string;
+  count: number;
+  firstAt: string;
+  lastAt: string;
+}
+const { t, locale } = useI18n();
+const notifications = useNotificationStore();
+const confirm = useConfirm();
+const { data, refresh, pending } = await useFetch<{ items: Miss[] }>('/api/admin/search-misses', {
+  query: { limit: 200 },
+  default: () => ({ items: [] }),
+});
+const items = computed(() => data.value?.items ?? []);
+const busy = ref<string | null>(null);
+
+async function remove(query: string) {
+  busy.value = query;
+  try {
+    await $fetch('/api/admin/search-misses', { method: 'DELETE', body: { query } });
+    await refresh();
+  } catch (err: any) {
+    notifications.error(err?.data?.message || t('admin.searchMisses.failed'));
+  } finally {
+    busy.value = null;
+  }
+}
+async function clearAll() {
+  const ok = await confirm({
+    title: t('admin.searchMisses.clearAll'),
+    message: t('admin.searchMisses.clearAllConfirm'),
+    confirmText: t('admin.searchMisses.clearAll'),
+    destructive: true,
+  });
+  if (!ok) return;
+  busy.value = '*';
+  try {
+    await $fetch('/api/admin/search-misses', { method: 'DELETE', body: {} });
+    await refresh();
+  } catch (err: any) {
+    notifications.error(err?.data?.message || t('admin.searchMisses.failed'));
+  } finally {
+    busy.value = null;
+  }
+}
+</script>
+
+<template>
+  <div class="card">
+    <div class="card-header">
+      <div class="flex items-center justify-between gap-3 flex-wrap">
+        <div class="flex items-center gap-2">
+          <Icon name="ph:magnifying-glass-minus-bold" class="text-text-muted" />
+          <h3 class="text-xs font-bold uppercase tracking-wider text-text-primary">
+            {{ $t('admin.searchMisses.title') }}
+          </h3>
+        </div>
+        <button
+          v-if="items.length"
+          type="button"
+          class="tool-btn tool-btn--text"
+          :disabled="busy !== null"
+          @click="clearAll"
+        >
+          <Icon name="ph:broom-bold" />
+          {{ $t('admin.searchMisses.clearAll') }}
+        </button>
+      </div>
+    </div>
+    <div class="card-body space-y-4">
+      <p class="text-xs text-text-muted leading-relaxed">{{ $t('admin.searchMisses.description') }}</p>
+      <p v-if="pending && !items.length" class="text-sm text-text-muted">…</p>
+      <p v-else-if="!items.length" class="text-sm text-text-muted">{{ $t('admin.searchMisses.empty') }}</p>
+      <div v-else class="overflow-x-auto">
+        <table class="w-full text-sm">
+          <thead>
+            <tr class="text-left text-xs uppercase tracking-wider text-text-muted">
+              <th class="py-2 pr-4">{{ $t('admin.searchMisses.query') }}</th>
+              <th class="py-2 pr-4 text-right">{{ $t('admin.searchMisses.count') }}</th>
+              <th class="py-2 pr-4">{{ $t('admin.searchMisses.last') }}</th>
+              <th class="py-2 pr-4">{{ $t('admin.searchMisses.first') }}</th>
+              <th class="py-2" />
+            </tr>
+          </thead>
+          <tbody>
+            <tr v-for="m in items" :key="m.query" class="border-t border-border">
+              <td class="py-2 pr-4 font-mono text-text-primary">{{ m.query }}</td>
+              <td class="py-2 pr-4 text-right tabular-nums text-text-primary">{{ m.count }}</td>
+              <td class="py-2 pr-4 text-text-muted">{{ formatAgo(m.lastAt, locale) }}</td>
+              <td class="py-2 pr-4 text-text-muted">{{ formatAgo(m.firstAt, locale) }}</td>
+              <td class="py-2">
+                <div class="flex items-center justify-end gap-1">
+                  <NuxtLink
+                    :to="{ path: '/requests/new', query: { title: m.query } }"
+                    class="tool-btn"
+                    :title="$t('admin.searchMisses.request')"
+                    :aria-label="$t('admin.searchMisses.request')"
+                  >
+                    <Icon name="ph:hand-palm-bold" />
+                  </NuxtLink>
+                  <NuxtLink
+                    :to="{ path: '/torrents', query: { q: m.query } }"
+                    class="tool-btn"
+                    :title="$t('admin.searchMisses.search')"
+                    :aria-label="$t('admin.searchMisses.search')"
+                  >
+                    <Icon name="ph:magnifying-glass-bold" />
+                  </NuxtLink>
+                  <button
+                    type="button"
+                    class="tool-btn"
+                    :disabled="busy !== null"
+                    :title="$t('admin.searchMisses.delete')"
+                    :aria-label="$t('admin.searchMisses.delete')"
+                    @click="remove(m.query)"
+                  >
+                    <Icon name="ph:x-bold" />
+                  </button>
+                </div>
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/web/app/components/admin/SearchSettings.vue b/apps/web/app/components/admin/SearchSettings.vue
index a77dd466..65a1ec4f 100644
--- a/apps/web/app/components/admin/SearchSettings.vue
+++ b/apps/web/app/components/admin/SearchSettings.vue
@@ -59,6 +59,61 @@
         {{ $t('admin.search.noneWarning') }}
       </p>
 
+      <!-- Le catalogue : ce qu'un membre trouve en arrivant. -->
+      <SettingsGroup
+        :control-id="fid('catalogue-view')"
+        :label="$t('admin.search.catalogue.view')"
+        :description="$t('admin.search.catalogue.viewHint')"
+      >
+        <select
+          :id="fid('catalogue-view')"
+          v-model="catalogueView"
+          class="rounded-md border border-border bg-bg-secondary px-2 py-1.5 text-sm text-text-primary"
+        >
+          <option v-for="v in VIEWS" :key="v" :value="v">{{ $t(`admin.search.catalogue.views.${v}`) }}</option>
+        </select>
+      </SettingsGroup>
+      <SettingsGroup
+        :control-id="fid('catalogue-sort')"
+        :label="$t('admin.search.catalogue.sort')"
+        :description="$t('admin.search.catalogue.sortHint')"
+      >
+        <select
+          :id="fid('catalogue-sort')"
+          v-model="catalogueSort"
+          class="rounded-md border border-border bg-bg-secondary px-2 py-1.5 text-sm text-text-primary"
+        >
+          <option v-for="s in SORTS" :key="s" :value="s">{{ $t(`admin.search.catalogue.sorts.${s}`) }}</option>
+        </select>
+      </SettingsGroup>
+      <SettingsGroup
+        :control-id="fid('catalogue-size')"
+        :label="$t('admin.search.catalogue.pageSize')"
+        :description="$t('admin.search.catalogue.pageSizeHint')"
+      >
+        <input
+          :id="fid('catalogue-size')"
+          v-model.number="cataloguePageSize"
+          type="number"
+          min="10"
+          max="50"
+          step="5"
+          class="w-24 rounded-md border border-border bg-bg-secondary px-2 py-1.5 text-sm text-text-primary"
+        />
+      </SettingsGroup>
+      <SettingsGroup
+        :control-id="fid(`catalogue-facets-${FACETS[0]}`)"
+        :label="$t('admin.search.catalogue.facets')"
+        :description="$t('admin.search.catalogue.facetsHint')"
+      >
+        <div class="grid grid-cols-2 gap-2 sm:grid-cols-3">
+          <label v-for="f in FACETS" :key="f" class="flex items-center gap-2 cursor-pointer text-sm text-text-primary">
+            <input :id="fid(`catalogue-facets-${f}`)" v-model="catalogueFacets" type="checkbox" :value="f" class="accent-text-primary" />
+            {{ $t(`admin.search.catalogue.facetNames.${f}`) }}
+          </label>
+        </div>
+      </SettingsGroup>
+
       <SettingsGroup
           :control-id="fid('fuzzy')"
         :label="$t('admin.search.fuzzy')"
@@ -108,17 +163,34 @@ type Field = (typeof FIELDS)[number];
 const fields = ref<Field[]>(['name', 'description']);
 // On by default: without it, a typo returns an empty page.
 const fuzzy = ref(true);
+// Le catalogue : la vue et le tri à l'arrivée, la taille d'une page, les facettes du rail.
+const VIEWS = ['grouped', 'simple'] as const;
+const SORTS = ['auto', 'age', 'name', 'size', 'seeders', 'leechers', 'completed'] as const;
+const FACETS = ['category', 'resolution', 'source', 'codec', 'language', 'hdr', 'audio', 'year', 'options'] as const;
+const catalogueView = ref<(typeof VIEWS)[number]>('grouped');
+const catalogueSort = ref<(typeof SORTS)[number]>('auto');
+const cataloguePageSize = ref(20);
+const catalogueFacets = ref<string[]>([...FACETS]);
 const loading = ref(false);
 const saved = ref(false);
 
-const { data } = await useFetch<{ searchFields?: Field[]; searchFuzzy?: boolean }>(
-  '/api/admin/settings',
-);
+const { data } = await useFetch<{
+  searchFields?: Field[];
+  searchFuzzy?: boolean;
+  catalogueDefaultView?: (typeof VIEWS)[number];
+  catalogueDefaultSort?: (typeof SORTS)[number];
+  cataloguePageSize?: number;
+  catalogueFacets?: string[];
+}>('/api/admin/settings');
 watch(
   data,
   (v) => {
     if (Array.isArray(v?.searchFields)) fields.value = [...v.searchFields];
     if (typeof v?.searchFuzzy === 'boolean') fuzzy.value = v.searchFuzzy;
+    if (v?.catalogueDefaultView) catalogueView.value = v.catalogueDefaultView;
+    if (v?.catalogueDefaultSort) catalogueSort.value = v.catalogueDefaultSort;
+    if (typeof v?.cataloguePageSize === 'number') cataloguePageSize.value = v.cataloguePageSize;
+    if (Array.isArray(v?.catalogueFacets)) catalogueFacets.value = [...v.catalogueFacets];
   },
   { immediate: true },
 );
@@ -134,6 +206,10 @@ async function save() {
       body: {
         searchFields: FIELDS.filter((f) => fields.value.includes(f)),
         searchFuzzy: fuzzy.value,
+        catalogueDefaultView: catalogueView.value,
+        catalogueDefaultSort: catalogueSort.value,
+        cataloguePageSize: Math.min(50, Math.max(10, Math.round(cataloguePageSize.value) || 20)),
+        catalogueFacets: FACETS.filter((f) => catalogueFacets.value.includes(f)),
       },
     });
     saved.value = true;
diff --git a/apps/web/app/components/admin/Stats.vue b/apps/web/app/components/admin/Stats.vue
index 0a8efea9..5002a0d0 100644
--- a/apps/web/app/components/admin/Stats.vue
+++ b/apps/web/app/components/admin/Stats.vue
@@ -91,7 +91,7 @@ function formatNumber(n: number): string {
 <style scoped>
 .metrics {
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 180px), 1fr));
   gap: 0.85rem;
 }
 
diff --git a/apps/web/app/components/admin/ThemeEditor.vue b/apps/web/app/components/admin/ThemeEditor.vue
index ef1c370b..841824ad 100644
--- a/apps/web/app/components/admin/ThemeEditor.vue
+++ b/apps/web/app/components/admin/ThemeEditor.vue
@@ -1238,7 +1238,7 @@ const familySuggestions = computed(() => {
 
 .token-grid {
   display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(15rem, 1fr));
+  grid-template-columns: repeat(auto-fill, minmax(min(100%, 15rem), 1fr));
   gap: 0.4rem 0.75rem;
   padding: 0.25rem 0 0.5rem;
 }
diff --git a/apps/web/app/components/admin/TorznabUsers.vue b/apps/web/app/components/admin/TorznabUsers.vue
index 9e3fda3c..06d709b6 100644
--- a/apps/web/app/components/admin/TorznabUsers.vue
+++ b/apps/web/app/components/admin/TorznabUsers.vue
@@ -97,7 +97,7 @@
               <td class="py-3 px-2">
                 <NuxtLink
                   :to="`/users/${user.username}`"
-                  class="text-sm font-medium text-text-primary hover:underline"
+                  class="inline-flex items-center min-h-[1.5rem] text-sm font-medium text-text-primary hover:underline"
                 >
                   {{ user.username }}
                 </NuxtLink>
diff --git a/apps/web/app/components/admin/UploadRulesToggle.vue b/apps/web/app/components/admin/UploadRulesToggle.vue
index 62f559d4..39ac4fd7 100644
--- a/apps/web/app/components/admin/UploadRulesToggle.vue
+++ b/apps/web/app/components/admin/UploadRulesToggle.vue
@@ -101,6 +101,9 @@ defineEmits<{
    thread the upload-rules surface with the other admin redesigns
    (notifications dispatch board, bonus rules console). */
 .urt-switch {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 22 px avant. */
+  min-height: 1.5rem;
+  align-items: center;
   position: relative;
   flex-shrink: 0;
   width: 2.45rem;
diff --git a/apps/web/app/components/admin/Users.vue b/apps/web/app/components/admin/Users.vue
index f7b0428d..e2de2151 100644
--- a/apps/web/app/components/admin/Users.vue
+++ b/apps/web/app/components/admin/Users.vue
@@ -1572,6 +1572,8 @@ async function onDetachRole(roleId: string) {
   font-variant-numeric: tabular-nums;
 }
 .kpi-sub {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 14 px avant. */
+  padding-block: 0.25rem;
   font-size: 0.6563rem;
   color: rgb(var(--fg-muted));
   letter-spacing: calc(0.04em * var(--tracking-scale));
@@ -1914,6 +1916,8 @@ async function onDetachRole(roleId: string) {
   min-width: 0;
 }
 .user-cell-name {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 20 px avant. */
+  padding-block: 0.25rem;
   font-size: 0.85rem;
   font-weight: 700;
   color: rgb(var(--fg-strong));
diff --git a/apps/web/app/components/nav/TorrentsMenu.vue b/apps/web/app/components/nav/TorrentsMenu.vue
new file mode 100644
index 00000000..39db5233
--- /dev/null
+++ b/apps/web/app/components/nav/TorrentsMenu.vue
@@ -0,0 +1,620 @@
+<script setup lang="ts">
+/**
+ * Le menu du catalogue, sous « Torrents » dans l'en-tête.
+ *
+ * Il s'ouvre au survol avec une intention (90 ms pour entrer, 220 ms de grâce
+ * pour en sortir), au clavier par le chevron ou la flèche bas, et au doigt par
+ * le chevron seul : le lien, lui, mène toujours au catalogue. Dedans, ce qui
+ * fait gagner un clic : les raccourcis (tout, du jour, gratuits, favoris), les
+ * recherches récentes de ce navigateur, puis les familles de catégories et
+ * leurs sous-catégories, chacune un lien direct vers le catalogue filtré.
+ *
+ * Les catégories ne sont demandées qu'à la première ouverture : l'en-tête est
+ * sur toutes les pages, le menu ne sert que sur certaines.
+ */
+import { getCategoryIcon } from '~/utils/categoryIcon';
+import type { RecentSearch } from '~/components/search/TokenSearch.vue';
+
+interface Category {
+  id: string;
+  name: string;
+  slug: string;
+  parentId: string | null;
+  icon?: string | null;
+  type?: string | null;
+  subcategories?: Category[];
+}
+
+defineProps<{ label: string; icon: string }>();
+const { t } = useI18n();
+const route = useRoute();
+
+const open = ref(false);
+const root = ref<HTMLElement | null>(null);
+const caret = ref<HTMLElement | null>(null);
+const panel = ref<HTMLElement | null>(null);
+const panelId = useId();
+/* Le panneau s'aligne à gauche du déclencheur ; s'il dépasse l'écran à droite, il recule d'autant. */
+const shift = ref(0);
+
+const isActive = computed(() => route.path === '/torrents' || route.path.startsWith('/torrents/'));
+
+/* ── Les données : à la première ouverture seulement ─────────────────────── */
+const {
+  data: categories,
+  execute: loadCategories,
+  status,
+} = useFetch<Category[]>('/api/categories', { immediate: false, server: false, lazy: true, default: () => [] });
+const loading = computed(() => status.value === 'pending');
+const families = computed(() => {
+  const all = categories.value ?? [];
+  const roots = all.filter((c) => !c.parentId);
+  return roots.map((r) => ({
+    ...r,
+    subcategories: (r.subcategories ?? all.filter((c) => c.parentId === r.id)).slice().sort((a, b) => a.name.localeCompare(b.name)),
+  }));
+});
+function hueOf(c: Category): number {
+  let h = 0;
+  for (const ch of c.slug || c.name) h = (h * 31 + ch.charCodeAt(0)) % 360;
+  return h;
+}
+const catLink = (id: string) => ({ path: '/torrents', query: { c: id } });
+
+const quick = computed(() => [
+  { key: 'all', icon: 'ph:squares-four-bold', label: t('nav.torrentsMenu.all'), hint: t('nav.torrentsMenu.allHint'), to: { path: '/torrents' } },
+  { key: 'today', icon: 'ph:sun-bold', label: t('nav.torrentsMenu.today'), hint: t('nav.torrentsMenu.todayHint'), to: { path: '/torrents', query: { o: 'today', v: 'simple' } } },
+  { key: 'free', icon: 'ph:gift-bold', label: t('nav.torrentsMenu.free'), hint: t('nav.torrentsMenu.freeHint'), to: { path: '/torrents', query: { o: 'free', v: 'simple' } } },
+  { key: 'favorites', icon: 'ph:star-bold', label: t('nav.torrentsMenu.favorites'), hint: t('nav.torrentsMenu.favoritesHint'), to: { path: '/torrents', query: { o: 'favorites' } } },
+]);
+
+/* Les recherches récentes de ce navigateur : la même réserve que la barre du catalogue. */
+const recent = ref<RecentSearch[]>([]);
+function readRecent() {
+  try {
+    const raw = localStorage.getItem('trackarr.recentSearches');
+    const parsed = raw ? (JSON.parse(raw) as RecentSearch[]) : [];
+    recent.value = Array.isArray(parsed) ? parsed.filter((r) => r && typeof r.label === 'string' && r.query).slice(0, 4) : [];
+  } catch {
+    recent.value = [];
+  }
+}
+
+/* ── Ouvrir, fermer, avec une intention ──────────────────────────────────── */
+let openTimer: ReturnType<typeof setTimeout> | null = null;
+let closeTimer: ReturnType<typeof setTimeout> | null = null;
+function clearTimers() {
+  if (openTimer) clearTimeout(openTimer);
+  if (closeTimer) clearTimeout(closeTimer);
+  openTimer = closeTimer = null;
+}
+function show() {
+  clearTimers();
+  if (open.value) return;
+  open.value = true;
+  readRecent();
+  if (!categories.value?.length && status.value !== 'pending') void loadCategories();
+  nextTick(fit);
+}
+function hide() {
+  clearTimers();
+  open.value = false;
+  shift.value = 0;
+}
+/* Le dernier pointeur vu sur le chevron : à la souris, le survol a déjà ouvert
+   et un clic ne doit pas refermer ; au clavier (detail 0) et au doigt, il bascule. */
+let lastPointerType = 'mouse';
+function onCaretPointerDown(e: PointerEvent) {
+  lastPointerType = e.pointerType || 'mouse';
+}
+function toggle(e?: MouseEvent) {
+  if (!open.value) {
+    show();
+    return;
+  }
+  const keyboard = !e || e.detail === 0;
+  if (keyboard || lastPointerType === 'touch') hide();
+}
+function onPointerEnter(e: PointerEvent) {
+  if (e.pointerType === 'touch') return;
+  if (closeTimer) {
+    clearTimeout(closeTimer);
+    closeTimer = null;
+  }
+  if (!open.value && !openTimer) openTimer = setTimeout(show, 90);
+}
+function onPointerLeave(e: PointerEvent) {
+  if (e.pointerType === 'touch') return;
+  if (openTimer) {
+    clearTimeout(openTimer);
+    openTimer = null;
+  }
+  if (open.value && !closeTimer) closeTimer = setTimeout(hide, 220);
+}
+function openFromKeyboard() {
+  show();
+  nextTick(() => panel.value?.querySelector<HTMLElement>('a')?.focus());
+}
+function onKeydown(e: KeyboardEvent) {
+  if (e.key !== 'Escape' || !open.value) return;
+  e.preventDefault();
+  hide();
+  caret.value?.focus();
+}
+function onFocusOut() {
+  // Le focus part ailleurs : on laisse le navigateur poser le nouveau focus avant de regarder où.
+  requestAnimationFrame(() => {
+    if (open.value && root.value && !root.value.contains(document.activeElement)) hide();
+  });
+}
+function onDocumentDown(e: PointerEvent) {
+  if (open.value && root.value && !root.value.contains(e.target as Node)) hide();
+}
+function fit() {
+  const el = panel.value;
+  if (!el) return;
+  shift.value = 0;
+  const r = el.getBoundingClientRect();
+  const over = r.right - (window.innerWidth - 12);
+  if (over > 0) shift.value = Math.min(over, r.left - 12);
+}
+
+watch(open, (v) => {
+  if (!import.meta.client) return;
+  if (v) document.addEventListener('pointerdown', onDocumentDown, { capture: true });
+  else document.removeEventListener('pointerdown', onDocumentDown, { capture: true });
+});
+// Une navigation ferme le menu : le lien cliqué a fait son travail.
+watch(() => route.fullPath, hide);
+onBeforeUnmount(() => {
+  clearTimers();
+  if (import.meta.client) document.removeEventListener('pointerdown', onDocumentDown, { capture: true });
+});
+</script>
+
+<template>
+  <div
+    ref="root"
+    class="tm"
+    :class="{ 'tm--open': open }"
+    @pointerenter="onPointerEnter"
+    @pointerleave="onPointerLeave"
+    @keydown="onKeydown"
+    @focusout="onFocusOut"
+  >
+    <div class="tm-trigger" :class="{ 'tm-trigger--active': isActive }">
+      <NuxtLink to="/torrents" class="tm-link" :title="label" @keydown.down.prevent="openFromKeyboard">
+        <Icon :name="icon" class="tm-link-ico" aria-hidden="true" />
+        <span class="tm-label">{{ label }}</span>
+      </NuxtLink>
+      <button
+        ref="caret"
+        type="button"
+        class="tm-caret"
+        :aria-expanded="open"
+        :aria-controls="open ? panelId : undefined"
+        :aria-label="t('nav.torrentsMenu.toggle')"
+        @pointerdown="onCaretPointerDown"
+        @click="toggle($event)"
+        @keydown.down.prevent="openFromKeyboard"
+      >
+        <Icon name="ph:caret-down-bold" class="tm-caret-ico" aria-hidden="true" />
+      </button>
+    </div>
+
+    <Transition name="tm">
+      <div
+        v-if="open"
+        :id="panelId"
+        ref="panel"
+        class="tm-panel"
+        role="group"
+        :style="{ '--tm-shift': `${shift}px` }"
+        :aria-label="t('nav.torrentsMenu.title')"
+      >
+        <div class="tm-quick">
+          <p class="tm-eyebrow">{{ t('nav.torrentsMenu.quick') }}</p>
+          <ul class="tm-list">
+            <li v-for="q in quick" :key="q.key">
+              <NuxtLink :to="q.to" class="tm-q">
+                <span class="tm-q-ico"><Icon :name="q.icon" aria-hidden="true" /></span>
+                <span class="tm-q-txt">
+                  <span class="tm-q-l">{{ q.label }}</span>
+                  <span class="tm-q-h">{{ q.hint }}</span>
+                </span>
+              </NuxtLink>
+            </li>
+          </ul>
+          <template v-if="recent.length">
+            <p class="tm-eyebrow tm-eyebrow--gap">{{ t('nav.torrentsMenu.recent') }}</p>
+            <ul class="tm-recent">
+              <li v-for="r in recent" :key="r.label">
+                <NuxtLink :to="{ path: '/torrents', query: r.query }" class="tm-pill" :title="r.label">
+                  <Icon name="ph:clock-counter-clockwise-bold" aria-hidden="true" />
+                  <span class="tm-pill-l">{{ r.label }}</span>
+                </NuxtLink>
+              </li>
+            </ul>
+          </template>
+        </div>
+
+        <div class="tm-fams">
+          <template v-if="loading && !families.length">
+            <div v-for="i in 4" :key="i" class="tm-skel" aria-hidden="true">
+              <span class="tm-skel-h" />
+              <span class="tm-skel-l" />
+              <span class="tm-skel-l" />
+              <span class="tm-skel-l tm-skel-l--short" />
+            </div>
+            <p class="sr-only" role="status">{{ t('nav.torrentsMenu.loading') }}</p>
+          </template>
+          <section v-for="fam in families" :key="fam.id" class="tm-fam">
+            <NuxtLink :to="catLink(fam.id)" class="tm-fam-h">
+              <span class="tm-fam-ico" :style="{ '--hue': hueOf(fam) }"><Icon :name="getCategoryIcon(fam)" aria-hidden="true" /></span>
+              <span class="tm-fam-name">{{ fam.name }}</span>
+            </NuxtLink>
+            <ul v-if="fam.subcategories.length" class="tm-kids">
+              <li v-for="kid in fam.subcategories" :key="kid.id">
+                <NuxtLink :to="catLink(kid.id)" class="tm-kid">{{ kid.name }}</NuxtLink>
+              </li>
+            </ul>
+          </section>
+          <p v-if="!loading && !families.length" class="tm-empty">
+            {{ status === 'error' ? t('nav.torrentsMenu.error') : t('nav.torrentsMenu.empty') }}
+          </p>
+        </div>
+      </div>
+    </Transition>
+  </div>
+</template>
+
+<style scoped>
+/* ── Le déclencheur : le lien de la barre, et un chevron qui lui est collé ── */
+.tm {
+  position: relative;
+  display: inline-flex;
+}
+.tm-trigger {
+  display: inline-flex;
+  align-items: center;
+  border-radius: 0.25rem;
+  color: rgb(var(--fg-muted) / 1);
+  transition:
+    background-color var(--dur-1) var(--ease-standard),
+    color var(--dur-1) var(--ease-standard);
+}
+.tm-trigger:hover,
+.tm--open .tm-trigger {
+  background: rgb(var(--fg-default) / 0.05);
+  color: rgb(var(--fg-default) / 1);
+}
+.tm-trigger--active {
+  background: rgb(var(--fg-default) / 0.1);
+  color: rgb(var(--fg-strong) / 1);
+}
+.tm-link {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 0.375rem 0.25rem 0.375rem 0.625rem;
+  font-size: 0.75rem;
+  font-weight: 500;
+  color: inherit;
+  text-decoration: none;
+  border-radius: 0.25rem;
+}
+.tm-link-ico {
+  width: 1rem;
+  height: 1rem;
+}
+.tm-label {
+  display: none;
+}
+@media (min-width: 96rem) {
+  .tm-label {
+    display: inline;
+  }
+}
+.tm-caret {
+  display: inline-grid;
+  place-items: center;
+  width: 1.5rem;
+  height: 1.75rem;
+  margin-right: 0.125rem;
+  border-radius: 0.25rem;
+  color: inherit;
+}
+.tm-caret-ico {
+  width: 0.6rem;
+  height: 0.6rem;
+  transition: transform var(--dur-2) var(--ease-standard);
+}
+.tm--open .tm-caret-ico {
+  transform: rotate(180deg);
+}
+
+/* ── Le panneau ──────────────────────────────────────────────────────────── */
+.tm-panel {
+  position: absolute;
+  top: calc(100% + 0.4rem);
+  left: 0;
+  z-index: 40;
+  display: grid;
+  grid-template-columns: 15rem minmax(0, 1fr);
+  gap: 0 1.25rem;
+  width: min(62rem, calc(100vw - 1.5rem));
+  margin-left: calc(-1 * var(--tm-shift, 0px));
+  padding: 1rem 1.25rem 1.1rem;
+  border: 1px solid rgb(var(--line-strong) / 1);
+  border-radius: var(--radius-lg);
+  background: rgb(var(--bg-elevated) / 0.97);
+  backdrop-filter: blur(12px);
+  box-shadow: var(--shadow-overlay);
+  color: rgb(var(--fg-default) / 1);
+  text-align: left;
+  cursor: default;
+}
+/* Le pont : la bande entre le déclencheur et le panneau reste « dedans » pour le survol. */
+.tm-panel::before {
+  content: '';
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: -0.5rem;
+  height: 0.5rem;
+}
+/* Le repère doré au bord haut, sous le déclencheur : d'où vient ce panneau. */
+.tm-panel::after {
+  content: '';
+  position: absolute;
+  top: -1px;
+  left: calc(var(--tm-shift, 0px) + 0.75rem);
+  width: 2.5rem;
+  height: 2px;
+  border-radius: 1px;
+  background: rgb(var(--accent-warm) / 1);
+}
+.tm-eyebrow {
+  margin: 0 0 0.5rem;
+  font-family: var(--font-mono);
+  font-size: 0.62rem;
+  font-weight: 700;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted) / 1);
+}
+.tm-eyebrow--gap {
+  margin-top: 1rem;
+}
+.tm-list,
+.tm-kids,
+.tm-recent {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
+/* Les raccourcis : une tuile, un libellé, un mot d'explication. */
+.tm-quick {
+  padding-right: 1.25rem;
+  border-right: 1px solid rgb(var(--line-default) / 1);
+}
+.tm-list {
+  display: grid;
+  gap: 0.15rem;
+}
+.tm-q {
+  display: flex;
+  align-items: center;
+  gap: 0.65rem;
+  padding: 0.35rem 0.5rem 0.35rem 0.35rem;
+  border-radius: var(--radius-sm);
+  color: inherit;
+  text-decoration: none;
+  transition: background-color var(--dur-1) var(--ease-standard);
+}
+.tm-q:hover {
+  background: rgb(var(--bg-hover) / 1);
+}
+.tm-q-ico {
+  flex: none;
+  display: inline-grid;
+  place-items: center;
+  width: 1.75rem;
+  height: 1.75rem;
+  border-radius: var(--radius-sm);
+  background: rgb(var(--bg-inset) / 1);
+  color: rgb(var(--fg-muted) / 1);
+  transition: color var(--dur-1) var(--ease-standard);
+}
+.tm-q-ico :deep(svg) {
+  width: 0.9rem;
+  height: 0.9rem;
+}
+.tm-q:hover .tm-q-ico {
+  color: rgb(var(--accent-warm-text) / 1);
+}
+.tm-q-txt {
+  display: grid;
+  min-width: 0;
+}
+.tm-q-l {
+  font-size: 0.8125rem;
+  font-weight: 600;
+  line-height: 1.25;
+  color: rgb(var(--fg-strong) / 1);
+}
+.tm-q-h {
+  font-size: 0.6875rem;
+  line-height: 1.3;
+  color: rgb(var(--fg-muted) / 1);
+}
+.tm-recent {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.35rem;
+}
+.tm-pill {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.3rem;
+  max-width: 100%;
+  height: 1.6rem;
+  padding: 0 0.55rem 0 0.45rem;
+  border: 1px solid rgb(var(--line-default) / 1);
+  border-radius: var(--radius-pill);
+  background: rgb(var(--bg-inset) / 1);
+  font-size: 0.75rem;
+  color: rgb(var(--fg-default) / 1);
+  text-decoration: none;
+  transition: border-color var(--dur-1) var(--ease-standard);
+}
+.tm-pill:hover {
+  border-color: rgb(var(--fg-muted) / 1);
+}
+.tm-pill :deep(svg) {
+  flex: none;
+  width: 0.7rem;
+  height: 0.7rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+.tm-pill-l {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* Les familles : en colonnes, chaque famille d'un bloc, ses enfants alignés sous son nom. */
+.tm-fams {
+  columns: 3 11rem;
+  column-gap: 1.5rem;
+}
+.tm-fam {
+  break-inside: avoid;
+  margin-bottom: 0.9rem;
+}
+.tm-fam-h {
+  display: flex;
+  align-items: center;
+  gap: 0.55rem;
+  padding: 0.2rem 0.35rem 0.2rem 0.2rem;
+  border-radius: var(--radius-sm);
+  color: rgb(var(--fg-strong) / 1);
+  text-decoration: none;
+}
+.tm-fam-h:hover .tm-fam-name {
+  text-decoration: underline;
+  text-decoration-color: rgb(var(--accent-warm) / 1);
+  text-underline-offset: 0.2em;
+}
+.tm-fam-ico {
+  flex: none;
+  display: inline-grid;
+  place-items: center;
+  width: 1.6rem;
+  height: 1.6rem;
+  border-radius: var(--radius-sm);
+  background: hsl(var(--hue, 40) 40% 50% / 0.16);
+  color: rgb(var(--fg-default) / 1);
+}
+.tm-fam-ico :deep(svg) {
+  width: 0.85rem;
+  height: 0.85rem;
+}
+.tm-fam-name {
+  font-size: 0.8125rem;
+  font-weight: 600;
+  line-height: 1.3;
+}
+.tm-kids {
+  margin-top: 0.15rem;
+  padding-left: 2.15rem;
+}
+.tm-kid {
+  display: block;
+  padding: 0.25rem 0.4rem;
+  margin-left: -0.4rem;
+  border-radius: var(--radius-xs);
+  font-size: 0.8125rem;
+  line-height: 1.3;
+  color: rgb(var(--fg-muted) / 1);
+  text-decoration: none;
+  transition:
+    color var(--dur-1) var(--ease-standard),
+    background-color var(--dur-1) var(--ease-standard);
+}
+.tm-kid:hover {
+  color: rgb(var(--fg-strong) / 1);
+  background: rgb(var(--bg-hover) / 1);
+}
+.tm-empty {
+  margin: 0;
+  font-size: 0.8125rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+
+/* Le squelette du premier chargement : la forme des familles, sans les mots. */
+.tm-skel {
+  display: grid;
+  gap: 0.4rem;
+  break-inside: avoid;
+  margin-bottom: 1rem;
+}
+.tm-skel-h,
+.tm-skel-l {
+  display: block;
+  height: 0.75rem;
+  border-radius: var(--radius-xs);
+  background: rgb(var(--fg-default) / 0.08);
+  animation: tm-pulse 1.2s ease-in-out infinite;
+}
+.tm-skel-h {
+  width: 60%;
+  height: 1rem;
+}
+.tm-skel-l {
+  width: 80%;
+  margin-left: 2.15rem;
+}
+.tm-skel-l--short {
+  width: 50%;
+}
+@keyframes tm-pulse {
+  50% {
+    opacity: 0.45;
+  }
+}
+
+/* ── L'entrée ────────────────────────────────────────────────────────────── */
+.tm-enter-active {
+  transition:
+    opacity var(--dur-2) var(--ease-emphasis),
+    transform var(--dur-2) var(--ease-emphasis);
+}
+.tm-leave-active {
+  transition:
+    opacity var(--dur-1) var(--ease-standard),
+    transform var(--dur-1) var(--ease-standard);
+}
+.tm-enter-from,
+.tm-leave-to {
+  opacity: 0;
+  transform: translateY(-0.3rem);
+}
+@media (prefers-reduced-motion: reduce) {
+  .tm-enter-active,
+  .tm-leave-active,
+  .tm-trigger,
+  .tm-caret-ico,
+  .tm-q,
+  .tm-q-ico,
+  .tm-pill,
+  .tm-kid {
+    transition: none;
+  }
+  .tm-skel-h,
+  .tm-skel-l {
+    animation: none;
+  }
+}
+</style>
diff --git a/apps/web/app/components/search/AlertsStrip.vue b/apps/web/app/components/search/AlertsStrip.vue
new file mode 100644
index 00000000..cf584e82
--- /dev/null
+++ b/apps/web/app/components/search/AlertsStrip.vue
@@ -0,0 +1,226 @@
+<script setup lang="ts">
+/**
+ * Mes alertes, à portée de main.
+ *
+ * Les recherches enregistrées existent depuis longtemps, mais vivaient dans
+ * une page à part. Ici, une pastille par alerte avec le nombre de releases
+ * arrivées depuis la dernière fois qu'on l'a ouverte d'ici — et « Enregistrer
+ * la recherche courante » pour poser la suivante sans quitter le catalogue.
+ */
+import { savedSearchLink, type SavedSearchCriteria } from '~/utils/savedSearchLink';
+
+interface SavedSearchItem extends SavedSearchCriteria {
+  id: string;
+  label: string;
+  notify: boolean;
+  matchCount: number;
+  seenCount?: number;
+  lastMatchedAt: string | null;
+}
+
+const props = withDefaults(
+  defineProps<{
+    canSave?: boolean;
+    saving?: boolean;
+    /** Incrémenté par la page quand une recherche vient d'être enregistrée. */
+    version?: number;
+    /** Dans le rail : en colonne, avec l'en-tête des facettes. */
+    rail?: boolean;
+  }>(),
+  { canSave: false, saving: false, version: 0, rail: false },
+);
+const emit = defineEmits<{ save: [] }>();
+
+const { t } = useI18n();
+const { data, refresh } = await useFetch<{ items: SavedSearchItem[]; max: number }>(
+  '/api/me/saved-searches',
+  { default: () => ({ items: [], max: 20 }) },
+);
+watch(
+  () => props.version,
+  () => {
+    void refresh();
+  },
+);
+
+const items = computed(() => data.value?.items ?? []);
+/** Dans le rail, cinq au plus : au-delà, la colonne des filtres deviendrait celle des alertes. « Gérer » porte le reste. */
+const RAIL_MAX = 5;
+const shown = computed(() => (props.rail ? items.value.slice(0, RAIL_MAX) : items.value));
+const hidden = computed(() => items.value.length - shown.value.length);
+const fresh = (s: SavedSearchItem) => Math.max(0, s.matchCount - (s.seenCount ?? 0));
+
+/** Ouvrir, c'est voir : le compteur retombe, sans attendre le serveur. */
+function open(s: SavedSearchItem) {
+  if (fresh(s) === 0) return;
+  // La charge utile de `useFetch` n'est pas réactive en profondeur : on la
+  // remplace, sinon le badge « nouv. » attend un rendu qui ne vient pas.
+  if (data.value) {
+    data.value = { ...data.value, items: data.value.items.map((it) => (it.id === s.id ? { ...it, seenCount: it.matchCount } : it)) };
+  }
+  void $fetch(`/api/me/saved-searches/${s.id}/seen`, { method: 'POST' }).catch(() => {
+    /* la prochaine ouverture recomptera */
+  });
+}
+</script>
+
+<template>
+  <section v-if="items.length || canSave" class="als" :class="{ 'als--rail': rail }" :aria-label="t('search.alerts.title')">
+    <h3 class="als-eyebrow">{{ t('search.alerts.title') }}</h3>
+    <NuxtLink
+      v-for="s in shown"
+      :key="s.id"
+      class="al"
+      :class="{ 'al--muted': !s.notify }"
+      :to="savedSearchLink(s)"
+      :title="s.notify ? undefined : t('search.alerts.muted')"
+      @click="open(s)"
+    >
+      <Icon :name="s.notify ? 'ph:bell-fill' : 'ph:bell-slash'" class="al-bell" aria-hidden="true" />
+      <span class="al-label">{{ s.label }}</span>
+      <span v-if="fresh(s)" class="al-new">{{ t('search.alerts.new', { n: fresh(s) }) }}</span>
+    </NuxtLink>
+    <button
+      v-if="canSave"
+      type="button"
+      class="al al--add"
+      :disabled="saving"
+      @click="emit('save')"
+    >
+      <Icon :name="saving ? 'ph:circle-notch' : 'ph:plus-bold'" :class="{ 'animate-spin': saving }" aria-hidden="true" />
+      {{ t('search.alerts.add') }}
+    </button>
+    <NuxtLink v-if="items.length" to="/alerts" class="als-manage">
+      {{ hidden > 0 ? t('search.alerts.manageMore', { n: hidden }) : t('search.alerts.manage') }}
+    </NuxtLink>
+  </section>
+</template>
+
+<style scoped>
+.als {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.4rem;
+  margin: 0.9rem 0 0;
+}
+.als-eyebrow {
+  margin: 0 0.25rem 0 0;
+  font-family: var(--font-mono);
+  font-size: 0.62rem;
+  font-weight: 700;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted) / 1);
+}
+.al {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.4rem;
+  min-height: 1.85rem;
+  max-width: 100%;
+  padding: 0 0.65rem;
+  border: 1px solid rgb(var(--line-default) / 1);
+  border-radius: var(--radius-pill);
+  background: rgb(var(--bg-surface) / 1);
+  font-size: 0.75rem;
+  font-weight: 500;
+  color: rgb(var(--fg-default) / 1);
+  text-decoration: none;
+  transition: border-color var(--dur-1) var(--ease-standard);
+}
+.al:hover {
+  border-color: rgb(var(--fg-muted) / 1);
+}
+.al-label {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.al-bell {
+  flex: none;
+  width: 0.75rem;
+  height: 0.75rem;
+  color: rgb(var(--accent-warm-text) / 1);
+}
+.al--muted .al-bell {
+  color: rgb(var(--fg-faint) / 1);
+}
+.al-new {
+  padding: 0 0.35rem;
+  border-radius: var(--radius-pill);
+  background: rgb(var(--accent-warm) / 1);
+  color: rgb(var(--accent-warm-fg) / 1);
+  font-family: var(--font-mono);
+  font-size: 0.625rem;
+  font-weight: 800;
+  line-height: 1.1rem;
+}
+.al--add {
+  border-style: dashed;
+  color: rgb(var(--fg-muted) / 1);
+}
+.al--add:hover {
+  color: rgb(var(--fg-strong) / 1);
+}
+.al--add:disabled {
+  opacity: 0.6;
+  cursor: progress;
+}
+.al--add :deep(svg) {
+  width: 0.7rem;
+  height: 0.7rem;
+}
+.als-manage {
+  margin-left: 0.25rem;
+  font-size: 0.75rem;
+  color: rgb(var(--fg-muted) / 1);
+  text-decoration: underline;
+  text-underline-offset: 3px;
+  text-decoration-color: rgb(var(--fg-faint) / 1);
+}
+.als-manage:hover {
+  color: rgb(var(--fg-strong) / 1);
+}
+/* Dans le rail : une section comme les facettes, les pastilles en colonne. */
+.als--rail {
+  flex-direction: column;
+  align-items: stretch;
+  gap: 0.3rem;
+  margin: 0;
+}
+.als--rail .als-eyebrow {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  margin: 0 0 0.35rem;
+}
+.als--rail .als-eyebrow::after {
+  content: '';
+  flex: 1;
+  height: 1px;
+  background: rgb(var(--line-default) / 1);
+}
+.als--rail .al {
+  justify-content: flex-start;
+  border-radius: var(--radius-sm);
+}
+.als--rail .al-label {
+  flex: 1;
+}
+.als--rail .als-manage {
+  margin: 0.15rem 0 0 0.25rem;
+  align-self: flex-start;
+}
+@media (pointer: coarse) {
+  .al {
+    min-height: 2.25rem;
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  .al {
+    transition: none;
+  }
+}
+</style>
diff --git a/apps/web/app/components/search/CatalogueFacets.vue b/apps/web/app/components/search/CatalogueFacets.vue
new file mode 100644
index 00000000..8ab5de37
--- /dev/null
+++ b/apps/web/app/components/search/CatalogueFacets.vue
@@ -0,0 +1,563 @@
+<script setup lang="ts">
+/**
+ * Le rail des facettes : ce qui existe dans la recherche courante, compté.
+ *
+ * Chaque valeur porte le nombre de releases qu'elle donnerait — on voit ce qui
+ * existe avant de filtrer, au lieu de découvrir une liste vide. Les comptes
+ * viennent de `/api/torrents/facets`, qui applique tous les filtres sauf celui
+ * de la dimension comptée : une catégorie cochée laisse ses voisines lisibles.
+ *
+ * Les étiquettes arrivent en slugs nus ; c'est le vocabulaire de la barre
+ * (`searchTokens.ts`) qui les range par famille — un slug sans famille
+ * (proper, 10bit…) ne s'affiche pas ici, il reste accessible par `tag=`.
+ */
+import { hasSlug, kindOfSlug, tagGroupIndex, type SearchToken, type TagKind } from '~/utils/searchTokens';
+import { categoryRows, familyRows, type FacetsResponse, type FacetCategory, type OptionKey } from '~/utils/catalogueFacets';
+import { formatAgo } from '~/utils/format';
+
+
+const props = withDefaults(
+  defineProps<{
+    facets: FacetsResponse | null;
+    loading?: boolean;
+    categories: FacetCategory[];
+    selectedCategory: string;
+    tokens: SearchToken[];
+    options: OptionKey[];
+    /** Dernière passe du collecteur : dit l'écart entre « avec des sources » et l'essaim vivant. */
+    statsAt?: string | null;
+    /** Les facettes que l'opérateur montre ; tout par défaut. */
+    visible?: string[];
+  }>(),
+  { loading: false, statsAt: null, visible: () => ['category', 'resolution', 'source', 'codec', 'language', 'hdr', 'audio', 'year', 'options'] },
+);
+const emit = defineEmits<{
+  selectCategory: [id: string];
+  toggleSlug: [kind: TagKind, slug: string];
+  toggleYear: [year: number];
+  toggleOption: [key: OptionKey];
+}>();
+
+const { t } = useI18n();
+
+/** Les familles montrées, dans l'ordre où l'on choisit une release. */
+const FAMILIES: readonly TagKind[] = ['resolution', 'source', 'codec', 'language', 'hdr', 'audio'];
+const LIMIT = 6;
+const expanded = ref(new Set<string>());
+
+/*
+ * Les sections repliées, mémorisées par le navigateur : un membre qui ne
+ * filtre jamais par audio n'a pas à le revoir à chaque visite.
+ */
+const COLLAPSED_KEY = 'trackarr.facets.collapsed';
+const collapsed = ref(new Set<string>());
+onMounted(() => {
+  try {
+    const raw = localStorage.getItem(COLLAPSED_KEY);
+    const list = raw ? (JSON.parse(raw) as string[]) : [];
+    if (Array.isArray(list)) collapsed.value = new Set(list.filter((k) => typeof k === 'string'));
+  } catch {
+    /* rien de plus */
+  }
+});
+const isCollapsed = (id: string) => collapsed.value.has(id);
+function toggleCollapsed(id: string) {
+  const next = new Set(collapsed.value);
+  if (next.has(id)) next.delete(id);
+  else next.add(id);
+  collapsed.value = next;
+  try {
+    localStorage.setItem(COLLAPSED_KEY, JSON.stringify([...next]));
+  } catch {
+    /* idem */
+  }
+}
+const isExpanded = (id: string) => expanded.value.has(id);
+function toggleExpanded(id: string) {
+  const next = new Set(expanded.value);
+  if (next.has(id)) next.delete(id);
+  else next.add(id);
+  expanded.value = next;
+}
+
+/* ── Catégories : les enfants comptent pour leur parent ───────────────────── */
+interface CatRow {
+  id: string;
+  name: string;
+  count: number;
+  kids: Array<{ id: string; name: string; count: number }>;
+}
+const show = (key: string) => props.visible.includes(key);
+const catRows = computed<CatRow[]>(() => (show('category') ? categoryRows(props.categories, props.facets?.categories ?? [], props.selectedCategory) : []));
+const openParentId = computed(() => {
+  const sel = props.selectedCategory;
+  if (!sel) return null;
+  return catRows.value.find((p) => p.id === sel || p.kids.some((k) => k.id === sel))?.id ?? null;
+});
+const visibleCats = computed(() =>
+  isExpanded('category') ? catRows.value : catRows.value.slice(0, LIMIT),
+);
+const isCatOn = (id: string) => props.selectedCategory === id;
+function pickCategory(id: string) {
+  emit('selectCategory', isCatOn(id) ? '' : id);
+}
+
+/* ── Étiquettes, par famille ──────────────────────────────────────────────── */
+interface FamilyRows {
+  kind: TagKind;
+  rows: Array<{ slug: string; name: string; count: number }>;
+}
+/*
+ * Une famille qui a un jeton se compte SANS lui (sinon sa valeur cochée serait
+ * la seule à rester, et on ne pourrait plus en changer) : ses lignes viennent
+ * de `tagsByGroup[i]`, les autres familles lisent les comptes stricts.
+ */
+const families = computed<FamilyRows[]>(() => {
+  const f = props.facets;
+  if (!f) return [];
+  return FAMILIES.filter((kind) => show(kind))
+    .map((kind) => ({ kind, rows: familyRows(f, tagGroupIndex(props.tokens, kind), (slug) => kindOfSlug(slug) === kind) }))
+    .filter((fam) => fam.rows.length > 0);
+});
+const visibleRows = (f: FamilyRows) => (isExpanded(f.kind) ? f.rows : f.rows.slice(0, LIMIT));
+
+/* ── Années : un petit histogramme des plus récentes ──────────────────────── */
+const selectedYear = computed(() => {
+  const tk = props.tokens.find((x) => x.kind === 'year');
+  return tk ? Number(tk.value) : null;
+});
+const years = computed(() => {
+  const all = [...(props.facets?.years ?? [])].sort((a, b) => a.year - b.year);
+  const recent = all.slice(-14);
+  const max = Math.max(1, ...recent.map((y) => y.count));
+  return recent.map((y) => ({ ...y, pct: Math.max(8, Math.round((100 * y.count) / max)) }));
+});
+
+/* ── Options : quatre questions de membre ─────────────────────────────────── */
+const optionRows = computed(() => {
+  const o = props.facets?.options;
+  return [
+    { key: 'seeded' as OptionKey, count: o?.withSeeders ?? 0 },
+    { key: 'today' as OptionKey, count: o?.today ?? 0 },
+    { key: 'free' as OptionKey, count: o?.freeleech ?? 0 },
+    { key: 'untaken' as OptionKey, count: o?.notTaken ?? 0 },
+    { key: 'current' as OptionKey, count: o?.superseded ?? 0 },
+    { key: 'favorites' as OptionKey, count: o?.favorites ?? 0 },
+  ];
+});
+const isOptionOn = (key: OptionKey) => props.options.includes(key);
+
+const empty = computed(
+  () => !props.loading && catRows.value.length === 0 && families.value.length === 0 && years.value.length === 0,
+);
+</script>
+
+<template>
+  <div class="cf" :class="{ 'cf--loading': loading }" :aria-busy="loading">
+    <p v-if="empty" class="cf-empty">{{ t('search.facets.none') }}</p>
+
+    <section v-if="catRows.length" class="facet">
+      <h3 class="fh">
+        <button type="button" class="fh-btn" :aria-expanded="!isCollapsed('category')" @click="toggleCollapsed('category')">
+          <span>{{ t('search.facets.category') }}</span>
+          <Icon name="ph:caret-down-bold" class="fh-car" :class="{ 'fh-car--closed': isCollapsed('category') }" aria-hidden="true" />
+        </button>
+      </h3>
+      <ul v-show="!isCollapsed('category')" class="flist">
+        <li v-for="cat in visibleCats" :key="cat.id">
+          <button
+            type="button"
+            class="frow"
+            :class="{ 'frow--on': isCatOn(cat.id) }"
+            :aria-pressed="isCatOn(cat.id)"
+            @click="pickCategory(cat.id)"
+          >
+            <span class="frow-l">{{ cat.name }}</span>
+            <span class="frow-c">{{ cat.count }}</span>
+          </button>
+          <ul v-if="openParentId === cat.id && cat.kids.length" class="flist flist--sub">
+            <li v-for="kid in cat.kids" :key="kid.id">
+              <button
+                type="button"
+                class="frow"
+                :class="{ 'frow--on': isCatOn(kid.id) }"
+                :aria-pressed="isCatOn(kid.id)"
+                @click="pickCategory(kid.id)"
+              >
+                <span class="frow-l">{{ kid.name }}</span>
+                <span class="frow-c">{{ kid.count }}</span>
+              </button>
+            </li>
+          </ul>
+        </li>
+      </ul>
+      <button
+        v-if="catRows.length > LIMIT && !isCollapsed('category')"
+        type="button"
+        class="frow-more"
+        :aria-expanded="isExpanded('category')"
+        @click="toggleExpanded('category')"
+      >
+        {{ isExpanded('category') ? t('search.facets.less') : t('search.facets.more', { n: catRows.length - LIMIT }) }}
+      </button>
+    </section>
+
+    <section v-for="fam in families" :key="fam.kind" class="facet">
+      <h3 class="fh">
+        <button type="button" class="fh-btn" :aria-expanded="!isCollapsed(fam.kind)" @click="toggleCollapsed(fam.kind)">
+          <span>{{ t(`search.facets.${fam.kind}`) }}</span>
+          <Icon name="ph:caret-down-bold" class="fh-car" :class="{ 'fh-car--closed': isCollapsed(fam.kind) }" aria-hidden="true" />
+        </button>
+      </h3>
+      <ul v-show="!isCollapsed(fam.kind)" class="flist">
+        <li v-for="row in visibleRows(fam)" :key="row.slug">
+          <button
+            type="button"
+            class="frow"
+            :class="{ 'frow--on': hasSlug(tokens, row.slug) }"
+            :aria-pressed="hasSlug(tokens, row.slug)"
+            @click="emit('toggleSlug', fam.kind, row.slug)"
+          >
+            <span class="frow-l">{{ row.name }}</span>
+            <span class="frow-c">{{ row.count }}</span>
+          </button>
+        </li>
+      </ul>
+      <button
+        v-if="fam.rows.length > LIMIT && !isCollapsed(fam.kind)"
+        type="button"
+        class="frow-more"
+        :aria-expanded="isExpanded(fam.kind)"
+        @click="toggleExpanded(fam.kind)"
+      >
+        {{ isExpanded(fam.kind) ? t('search.facets.less') : t('search.facets.more', { n: fam.rows.length - LIMIT }) }}
+      </button>
+    </section>
+
+    <section v-if="show('year') && years.length" class="facet">
+      <h3 class="fh">
+        <button type="button" class="fh-btn" :aria-expanded="!isCollapsed('year')" @click="toggleCollapsed('year')">
+          <span>{{ t('search.facets.year') }}</span>
+          <Icon name="ph:caret-down-bold" class="fh-car" :class="{ 'fh-car--closed': isCollapsed('year') }" aria-hidden="true" />
+        </button>
+      </h3>
+      <div v-show="!isCollapsed('year')" class="years" :class="{ 'years--full': years.length <= 8 }" role="group" :aria-label="t('search.facets.year')">
+        <button
+          v-for="y in years"
+          :key="y.year"
+          type="button"
+          class="yb"
+          :class="{ 'yb--on': selectedYear === y.year }"
+          :aria-pressed="selectedYear === y.year"
+          :title="t('search.facets.yearTitle', { year: y.year, n: y.count }, y.count)"
+          :aria-label="t('search.facets.yearTitle', { year: y.year, n: y.count }, y.count)"
+          @click="emit('toggleYear', y.year)"
+        >
+          <span class="ybar" :style="{ height: `${y.pct}%` }" />
+          <span class="yl">{{ years.length <= 8 ? y.year : String(y.year).slice(2) }}</span>
+        </button>
+      </div>
+    </section>
+
+    <section v-if="show('options')" class="facet facet--opts">
+      <h3 class="fh">
+        <button type="button" class="fh-btn" :aria-expanded="!isCollapsed('options')" @click="toggleCollapsed('options')">
+          <span>{{ t('search.facets.options') }}</span>
+          <Icon name="ph:caret-down-bold" class="fh-car" :class="{ 'fh-car--closed': isCollapsed('options') }" aria-hidden="true" />
+        </button>
+      </h3>
+      <ul v-show="!isCollapsed('options')" class="flist">
+        <li v-for="opt in optionRows" :key="opt.key">
+          <button
+            type="button"
+            class="frow frow--switch"
+            :class="{ 'frow--on': isOptionOn(opt.key) }"
+            role="switch"
+            :aria-checked="isOptionOn(opt.key)"
+            @click="emit('toggleOption', opt.key)"
+          >
+            <span class="sw-mini" aria-hidden="true" />
+            <span class="frow-l">{{ t(`search.options.${opt.key}`) }}</span>
+            <span class="frow-c">{{ opt.count }}</span>
+          </button>
+        </li>
+      </ul>
+      <p v-if="statsAt" class="cf-fresh">{{ t('search.facets.fresh', { ago: formatAgo(statsAt) }) }}</p>
+    </section>
+  </div>
+</template>
+
+<style scoped>
+.cf {
+  display: grid;
+  gap: 1.1rem;
+  transition: opacity var(--dur-2) var(--ease-standard);
+}
+.cf--loading {
+  opacity: 0.6;
+}
+.cf-empty {
+  margin: 0;
+  font-size: 0.8125rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+.cf-fresh {
+  margin: 0.35rem 0 0 0.5rem;
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+.facet {
+  position: relative;
+}
+.fh {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  margin: 0 0 0.35rem;
+  min-width: 0;
+  font-family: var(--font-mono);
+  font-size: 0.62rem;
+  font-weight: 700;
+  line-height: 1;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted) / 1);
+}
+.fh::after {
+  content: '';
+  flex: 1;
+  height: 1px;
+  background: rgb(var(--line-default) / 1);
+}
+.fh-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  min-height: 1.5rem;
+  padding: 0 0.15rem;
+  margin-left: -0.15rem;
+  border-radius: var(--radius-xs);
+  font: inherit;
+  letter-spacing: inherit;
+  text-transform: inherit;
+  color: inherit;
+}
+.fh-btn:hover {
+  color: rgb(var(--fg-strong) / 1);
+}
+.fh-car {
+  width: 0.55rem;
+  height: 0.55rem;
+  transition: transform var(--dur-2) var(--ease-standard);
+}
+.fh-car--closed {
+  transform: rotate(-90deg);
+}
+.flist {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: grid;
+}
+.flist--sub {
+  margin-left: 1.1rem;
+  border-left: 1px solid rgb(var(--line-default) / 1);
+}
+.frow {
+  position: relative;
+  width: 100%;
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  min-height: 1.85rem;
+  padding: 0 0.5rem 0 1.45rem;
+  border-radius: var(--radius-sm);
+  color: rgb(var(--fg-default) / 1);
+  font-size: 0.8125rem;
+  text-align: left;
+  transition: background-color var(--dur-1) var(--ease-standard);
+}
+.frow::before {
+  content: '';
+  position: absolute;
+  left: 0.3rem;
+  top: 50%;
+  width: 0.875rem;
+  height: 0.875rem;
+  transform: translateY(-50%);
+  border: 1px solid rgb(var(--line-field) / 1);
+  border-radius: 3px;
+  background: rgb(var(--bg-inset) / 1);
+  transition: background-color var(--dur-1) var(--ease-standard), border-color var(--dur-1) var(--ease-standard);
+}
+/* La coche : deux traits, dessinés dans la case quand elle est cochée. */
+.frow::after {
+  content: '';
+  position: absolute;
+  left: 0.6rem;
+  top: calc(50% - 0.35rem);
+  width: 0.3rem;
+  height: 0.55rem;
+  border: solid rgb(var(--accent-warm-fg) / 1);
+  border-width: 0 2px 2px 0;
+  transform: rotate(45deg) scale(0);
+  transition: transform var(--dur-1) var(--ease-emphasis);
+}
+.frow--on::after {
+  transform: rotate(45deg) scale(1);
+}
+.facet--opts .frow::after {
+  display: none;
+}
+.frow:hover {
+  background: rgb(var(--bg-hover) / 1);
+}
+.frow--on {
+  color: rgb(var(--fg-strong) / 1);
+  font-weight: 600;
+}
+.frow--on::before {
+  background: rgb(var(--accent-warm) / 1);
+  border-color: rgb(var(--accent-warm) / 1);
+}
+.frow-l {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.frow-c {
+  margin-left: auto;
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  font-variant-numeric: tabular-nums;
+  color: rgb(var(--fg-muted) / 1);
+}
+.frow--on .frow-c {
+  color: rgb(var(--accent-warm-text) / 1);
+}
+.frow-more {
+  margin: 0.25rem 0 0 1.45rem;
+  font-size: 0.75rem;
+  font-weight: 600;
+  color: rgb(var(--fg-default) / 1);
+  text-decoration: underline;
+  text-underline-offset: 3px;
+  text-decoration-color: rgb(var(--fg-faint) / 1);
+  border-radius: var(--radius-xs);
+}
+.frow-more:hover {
+  color: rgb(var(--fg-strong) / 1);
+  text-decoration-color: rgb(var(--accent-warm) / 1);
+}
+
+/* ── Années ──────────────────────────────────────────────────────────────── */
+/* L'histogramme repose sur une ligne de base : sans elle, les barres flottaient. */
+.years {
+  display: flex;
+  align-items: flex-end;
+  gap: 0.25rem;
+  height: 3.6rem;
+  padding: 0 0.3rem;
+  border-bottom: 1px solid rgb(var(--line-default) / 1);
+}
+.years--full .yl {
+  font-size: 0.625rem;
+  letter-spacing: -0.02em;
+}
+.yb {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-end;
+  align-items: stretch;
+  gap: 0.25rem;
+  height: 100%;
+  min-width: 0;
+  border-radius: var(--radius-xs);
+}
+.ybar {
+  display: block;
+  min-height: 3px;
+  border-radius: 2px 2px 0 0;
+  background: rgb(var(--fg-default) / 0.18);
+  transition: background-color var(--dur-1) var(--ease-standard);
+}
+.yb:hover .ybar {
+  background: rgb(var(--fg-default) / 0.35);
+}
+.yb--on .ybar {
+  background: rgb(var(--accent-warm) / 1);
+}
+.yl {
+  font-family: var(--font-mono);
+  font-size: 0.625rem;
+  font-weight: 600;
+  line-height: 1;
+  text-align: center;
+  color: rgb(var(--fg-muted) / 1);
+}
+.yb--on .yl {
+  color: rgb(var(--accent-warm-text) / 1);
+}
+
+/* ── Options : des interrupteurs, pas des cases ──────────────────────────── */
+.facet--opts .frow {
+  padding-left: 0.5rem;
+}
+.facet--opts .frow::before {
+  display: none;
+}
+.sw-mini {
+  position: relative;
+  flex: none;
+  width: 1.9rem;
+  height: 1.05rem;
+  margin-right: 0.2rem;
+  border-radius: var(--radius-pill);
+  background: rgb(var(--line-strong) / 1);
+  transition: background-color var(--dur-2) var(--ease-standard);
+}
+.sw-mini::after {
+  content: '';
+  position: absolute;
+  top: 2px;
+  left: 2px;
+  width: 0.8rem;
+  height: 0.8rem;
+  border-radius: 50%;
+  background: rgb(var(--fg-default) / 1);
+  transition: left var(--dur-2) var(--ease-standard), background-color var(--dur-2) var(--ease-standard);
+}
+.frow--on .sw-mini {
+  background: rgb(var(--accent-warm) / 1);
+}
+.frow--on .sw-mini::after {
+  left: calc(100% - 0.8rem - 2px);
+  background: rgb(var(--accent-warm-fg) / 1);
+}
+@media (pointer: coarse) {
+  .frow {
+    min-height: 2.75rem;
+  }
+  .yb {
+    min-width: 2rem;
+  }
+  .frow-more {
+    min-height: 2.25rem;
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  .cf,
+  .frow,
+  .frow::before,
+  .frow::after,
+  .fh-car,
+  .ybar,
+  .sw-mini,
+  .sw-mini::after {
+    transition: none;
+  }
+}
+</style>
diff --git a/apps/web/app/components/search/PinnedCards.vue b/apps/web/app/components/search/PinnedCards.vue
new file mode 100644
index 00000000..af8b2d91
--- /dev/null
+++ b/apps/web/app/components/search/PinnedCards.vue
@@ -0,0 +1,176 @@
+<script setup lang="ts">
+/**
+ * Les épinglés en cartes.
+ *
+ * Un tableau qui répétait la structure des résultats disait « encore des
+ * lignes » ; une carte avec l'affiche dit « l'équipe met ceci en avant », et
+ * se reconnaît d'un coup d'œil. Ce que la carte porte tient en une ligne :
+ * l'unité, la résolution et la source, la taille, et « gratuit » quand c'est
+ * le moment de la prendre.
+ */
+import { formatSize } from '~/utils/format';
+import { kindOfSlug } from '~/utils/searchTokens';
+import type { CatalogueRow } from './ReleaseRows.vue';
+
+defineProps<{ torrents: CatalogueRow[] }>();
+const { t } = useI18n();
+
+const titleOf = (row: CatalogueRow) => row.work?.title || row.name;
+const unit = (row: CatalogueRow) => {
+  const parts: string[] = [];
+  if (typeof row.season === 'number') parts.push(`S${String(row.season).padStart(2, '0')}`);
+  if (typeof row.episode === 'number') parts.push(`E${String(row.episode).padStart(2, '0')}`);
+  return parts.join('');
+};
+function meta(row: CatalogueRow): string[] {
+  const out: string[] = [];
+  const u = unit(row);
+  if (u) out.push(u);
+  const tags = row.tags ?? [];
+  const pick = (kind: string) => tags.find((tg) => kindOfSlug(tg.slug) === kind)?.name;
+  const res = pick('resolution');
+  const src = pick('source');
+  if (res || src) out.push([res, src].filter(Boolean).join(' '));
+  const hdr = pick('hdr');
+  if (hdr) out.push(hdr);
+  out.push(formatSize(row.size));
+  return out;
+}
+</script>
+
+<template>
+  <section class="pins" :aria-label="t('search.pinned.title')">
+    <span class="pins-eyebrow">
+      <Icon name="ph:push-pin-fill" aria-hidden="true" />
+      {{ t('search.pinned.title') }}
+    </span>
+    <NuxtLink v-for="row in torrents" :key="row.id" class="pcard" :to="`/torrents/${row.infoHash}`">
+      <TorrentPosterHover
+        class="pcard-pst"
+        :src="row.work?.posterUrl ?? null"
+        :large="row.work?.posterUrl?.replace('/w342/', '/w500/') ?? null"
+        :alt="titleOf(row)"
+        fallback-icon="ph:push-pin-bold"
+      />
+      <span class="pcard-body">
+        <span class="pcard-title" :class="{ 'pcard-title--mono': !row.work?.title }" :title="row.name">
+          {{ titleOf(row) }}<span v-if="row.work?.year" class="pcard-year"> {{ row.work.year }}</span>
+        </span>
+        <span class="pcard-meta">
+          <template v-for="(m, i) in meta(row)" :key="i">
+            <span v-if="i > 0" aria-hidden="true"> · </span>{{ m }}
+          </template>
+          <template v-if="row.freeleech">
+            <span aria-hidden="true"> · </span><span class="pcard-free">{{ t('search.pinned.free') }}</span>
+          </template>
+        </span>
+      </span>
+    </NuxtLink>
+  </section>
+</template>
+
+<style scoped>
+/* Le repère au-dessus, horizontal comme tous ceux de la page ; les cartes en
+   colonnes de 18rem au moins, jamais une seule étirée sur toute la largeur. */
+.pins {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(18rem, 1fr));
+  gap: 0.5rem 0.6rem;
+  margin: 0 0 1rem;
+}
+.pins-eyebrow {
+  grid-column: 1 / -1;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  font-family: var(--font-mono);
+  font-size: 0.62rem;
+  font-weight: 700;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: rgb(var(--accent-warm-text) / 1);
+}
+.pins-eyebrow :deep(svg) {
+  width: 0.7rem;
+  height: 0.7rem;
+}
+.pcard {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  min-width: 0;
+  padding: 0.55rem 0.75rem 0.55rem 0.55rem;
+  border: 1px solid rgb(var(--accent-warm) / 0.4);
+  border-radius: var(--radius-lg);
+  background:
+    linear-gradient(90deg, rgb(var(--accent-warm) / 0.08), transparent 60%),
+    rgb(var(--bg-surface) / 1);
+  color: inherit;
+  text-decoration: none;
+  transition: border-color var(--dur-1) var(--ease-standard), transform var(--dur-2) var(--ease-standard);
+}
+.pcard:hover {
+  border-color: rgb(var(--accent-warm) / 0.8);
+  transform: translateY(-1px);
+}
+.pcard-pst {
+  flex: none;
+  width: 40px;
+  height: 60px;
+  border-radius: var(--radius-sm);
+  overflow: hidden;
+}
+.pcard-body {
+  display: grid;
+  gap: 0.15rem;
+  min-width: 0;
+}
+.pcard-title {
+  display: block;
+  font-family: var(--font-display);
+  font-style: italic;
+  font-weight: 500;
+  font-size: 1rem;
+  line-height: 1.15;
+  color: rgb(var(--fg-strong) / 1);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.pcard-title--mono {
+  font-family: var(--font-mono);
+  font-style: normal;
+  font-size: 0.75rem;
+}
+.pcard-year {
+  font-weight: 400;
+  color: rgb(var(--fg-muted) / 1);
+}
+.pcard-meta {
+  display: block;
+  font-family: var(--font-mono);
+  font-size: 0.625rem;
+  font-weight: 500;
+  line-height: 1.5;
+  color: rgb(var(--fg-muted) / 1);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.pcard-free {
+  color: rgb(var(--accent-warm-text) / 1);
+  font-weight: 700;
+}
+/* Étroit : la ligne méta passe sur deux lignes plutôt que de couper « gratuit ». */
+@media (max-width: 40rem) {
+  .pcard-meta {
+    white-space: normal;
+    overflow-wrap: anywhere;
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  .pcard {
+    transition: none;
+  }
+}
+</style>
diff --git a/apps/web/app/components/search/ReleaseRows.vue b/apps/web/app/components/search/ReleaseRows.vue
new file mode 100644
index 00000000..bedbcb59
--- /dev/null
+++ b/apps/web/app/components/search/ReleaseRows.vue
@@ -0,0 +1,797 @@
+<script setup lang="ts">
+/**
+ * Les lignes du catalogue.
+ *
+ * Une ligne répond, dans l'ordre où l'œil lit : de quoi il s'agit (le titre de
+ * l'œuvre quand le cache le connaît, sinon le nom de la release), dans quelle
+ * unité (S02 · E04), ce qu'il faut savoir avant de cliquer (gratuit, remplacée,
+ * déjà prise), puis la qualité en puces, la taille, l'essaim et qui l'a
+ * envoyée. La pastille de gauche dit l'état de l'essaim sans qu'on lise les
+ * chiffres — et pas seulement par la couleur : son titre le nomme.
+ *
+ * Tout est au clavier : flèches pour parcourir, Entrée pour ouvrir, D pour
+ * télécharger, F pour le favori — les mêmes touches que la fiche.
+ */
+import { formatAge, formatDate, formatSize } from '~/utils/format';
+import { groupVersions as groupRows, type VersionGroup } from '~/utils/releaseVersions';
+
+export interface CatalogueRow {
+  id: string;
+  infoHash: string;
+  name: string;
+  size: number;
+  createdAt: string;
+  season?: number | null;
+  episode?: number | null;
+  isSticky?: boolean;
+  supersededById?: string | null;
+  freeleech?: boolean;
+  viewerTaken?: boolean;
+  viewerFavorited?: boolean;
+  uploader?: { id: string; username: string | null } | null;
+  /** Vrai quand un uploadeur réel est masqué — pas quand le compte a disparu. */
+  uploaderAnonymous?: boolean;
+  work?: { source?: string; id?: string; title: string; year: number | null; posterUrl: string | null; type: string | null; tint?: string | null } | null;
+  category?: { id: string; name: string; icon?: string | null } | null;
+  tags?: Array<{ id: string; name: string; slug: string; color?: string | null }> | null;
+  stats: { seeders: number; leechers: number; completed: number };
+}
+
+const props = withDefaults(
+  defineProps<{
+    torrents: CatalogueRow[];
+    dense?: boolean;
+    /** Le bloc des épinglés : même lignes, teinte chaude, sans en-tête. */
+    pinned?: boolean;
+    showHeader?: boolean;
+    /** Replier les autres versions d'un même contenu derrière la première. */
+    groupVersions?: boolean;
+    /** Dans une carte d'œuvre : l'œuvre est connue, la ligne ne la répète pas. */
+    nested?: boolean;
+  }>(),
+  { dense: false, pinned: false, showHeader: true, groupVersions: false, nested: false },
+);
+
+/* ── Les versions : même œuvre, même unité → une tête, les autres repliées ── */
+const expandedVersions = ref(new Set<string>());
+const groups = computed<VersionGroup<CatalogueRow>[]>(() =>
+  props.groupVersions ? groupRows(props.torrents) : props.torrents.map((r) => ({ key: r.id, lead: r, others: [] })),
+);
+/**
+ * Les lignes affichées : chaque tête, puis ses autres versions si dépliées.
+ * `repeat` : la ligne précédente montrait déjà cette œuvre — le titre s'efface,
+ * comme dans un registre, pour que l'œil ne relise pas dix fois la même chose.
+ */
+const shown = computed(() => {
+  const out: Array<{ row: CatalogueRow; versions: number; key: string; isVersion: boolean; repeat: boolean }> = [];
+  let previousWork: string | null = null;
+  for (const g of groups.value) {
+    const items = [g.lead, ...(expandedVersions.value.has(g.key) ? g.others : [])];
+    items.forEach((row, i) => {
+      const work = row.work?.id ? `${row.work.source ?? ''}:${row.work.id}` : null;
+      out.push({ row, versions: i === 0 ? g.others.length : 0, key: g.key, isVersion: i > 0, repeat: !!work && work === previousWork });
+      previousWork = work;
+    });
+  }
+  return out;
+});
+function toggleVersions(key: string) {
+  const next = new Set(expandedVersions.value);
+  if (next.has(key)) next.delete(key);
+  else next.add(key);
+  expandedVersions.value = next;
+}
+
+const { t } = useI18n();
+const notifications = useNotificationStore();
+const listRef = ref<HTMLElement | null>(null);
+
+/* ── Favoris : optimiste, annulé si le serveur refuse ─────────────────────── */
+const favOverride = ref(new Map<string, boolean>());
+const isFavorited = (row: CatalogueRow) => favOverride.value.get(row.infoHash) ?? !!row.viewerFavorited;
+async function toggleFavorite(row: CatalogueRow) {
+  const before = isFavorited(row);
+  favOverride.value.set(row.infoHash, !before);
+  try {
+    await $fetch(`/api/torrents/${row.infoHash}/favorite`, { method: before ? 'DELETE' : 'POST' });
+  } catch (err: any) {
+    favOverride.value.set(row.infoHash, before);
+    notifications.error(err?.data?.message || t('components.torrentTable.errors.favoriteFailed'));
+  }
+}
+
+/* ── L'état de l'essaim, lisible sans les chiffres ────────────────────────── */
+type SwarmState = 'dead' | 'thin' | 'ok' | 'hot';
+function swarmState(row: CatalogueRow): SwarmState {
+  const s = row.stats.seeders;
+  if (s === 0) return 'dead';
+  if (s < 3) return 'thin';
+  if (s >= 20) return 'hot';
+  return 'ok';
+}
+const swarmTitle = (row: CatalogueRow) =>
+  t(`search.rows.swarm.${swarmState(row)}`, { s: row.stats.seeders, l: row.stats.leechers });
+
+const unit = (row: CatalogueRow) => {
+  const parts: string[] = [];
+  if (typeof row.season === 'number') parts.push(`S${String(row.season).padStart(2, '0')}`);
+  if (typeof row.episode === 'number') parts.push(`E${String(row.episode).padStart(2, '0')}`);
+  return parts.join(' · ');
+};
+
+const detailTo = (row: CatalogueRow) => `/torrents/${row.infoHash}`;
+const downloadHref = (row: CatalogueRow) => `/api/torrents/${row.infoHash}/download`;
+
+/* ── Clavier : ↑↓ parcourir, D télécharger, F favori ──────────────────────── */
+function rowsEls(): HTMLElement[] {
+  return Array.from(listRef.value?.querySelectorAll<HTMLElement>('.rr-row') ?? []);
+}
+function onKey(e: KeyboardEvent) {
+  if (e.defaultPrevented || e.isComposing || e.metaKey || e.ctrlKey || e.altKey) return;
+  const target = e.target as HTMLElement | null;
+  if (!target || target.tagName === 'INPUT' || target.tagName === 'TEXTAREA') return;
+  const rowEl = target.closest<HTMLElement>('.rr-row');
+  if (!rowEl) return;
+  const rows = rowsEls();
+  const i = rows.indexOf(rowEl);
+  if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
+    const next = rows[i + (e.key === 'ArrowDown' ? 1 : -1)];
+    if (!next) return;
+    e.preventDefault();
+    next.querySelector<HTMLElement>('.rr-primary')?.focus();
+    return;
+  }
+  if (e.key === 'd' || e.key === 'D') {
+    const a = rowEl.querySelector<HTMLAnchorElement>('.rr-dl');
+    if (a) {
+      e.preventDefault();
+      a.click();
+    }
+    return;
+  }
+  if (e.key === 'f' || e.key === 'F') {
+    const b = rowEl.querySelector<HTMLButtonElement>('.rr-fav');
+    if (b) {
+      e.preventDefault();
+      b.click();
+    }
+  }
+}
+</script>
+
+<template>
+  <div
+    ref="listRef"
+    class="rr"
+    :class="{ 'rr--dense': dense, 'rr--pinned': pinned, 'rr--nested': nested }"
+    @keydown="onKey"
+  >
+    <div v-if="showHeader && torrents.length" class="rr-head" aria-hidden="true">
+      <span />
+      <span>{{ t('search.rows.release') }}</span>
+      <span>{{ t('search.rows.quality') }}</span>
+      <span class="rr-num">{{ t('search.rows.size') }}</span>
+      <span class="rr-num">{{ t('search.rows.swarm.label') }}</span>
+      <span class="rr-col-by">{{ t('search.rows.by') }}</span>
+      <span class="rr-col-age">{{ t('search.rows.age') }}</span>
+      <span /><span />
+    </div>
+    <ul class="rr-list">
+      <li
+        v-for="{ row, versions, key, isVersion, repeat } in shown"
+        :key="row.id"
+        class="rr-row"
+        :data-state="swarmState(row)"
+        :class="{ 'is-taken': row.viewerTaken, 'is-old': !!row.supersededById, 'rr-row--version': isVersion, 'rr-row--repeat': repeat && !nested }"
+      >
+        <span class="rr-pip" :title="swarmTitle(row)"><span class="sr-only">{{ swarmTitle(row) }}</span></span>
+
+        <div class="rr-main">
+          <div class="rr-l1">
+            <NuxtLink
+              class="rr-title rr-primary"
+              :class="{ 'rr-title--name': nested || !row.work?.title }"
+              :to="detailTo(row)"
+              :title="row.name"
+            >
+              <template v-if="row.work?.title && !nested">
+                {{ row.work.title }}<span v-if="row.work.year" class="rr-year"> {{ row.work.year }}</span>
+              </template>
+              <template v-else>{{ row.name }}</template>
+            </NuxtLink>
+            <span v-if="unit(row)" class="rr-unit">{{ unit(row) }}</span>
+            <span v-if="row.freeleech" class="rr-badge rr-badge--free" :title="t('search.rows.freeHint')">{{ t('search.rows.free') }}</span>
+            <span v-if="row.supersededById" class="rr-badge rr-badge--old" :title="t('search.rows.replacedHint')">{{ t('search.rows.replaced') }}</span>
+            <span v-if="row.viewerTaken" class="rr-badge rr-badge--taken" :title="t('search.rows.takenHint')">
+              <Icon name="ph:check-bold" aria-hidden="true" />{{ t('search.rows.taken') }}
+            </span>
+            <button
+              v-if="versions > 0"
+              type="button"
+              class="rr-versions"
+              :aria-expanded="expandedVersions.has(key)"
+              @click.stop="toggleVersions(key)"
+            >
+              {{ expandedVersions.has(key) ? t('search.rows.versionsHide') : t('search.rows.versions', versions) }}
+            </button>
+          </div>
+          <p v-if="row.work?.title && !nested" class="rr-name" :title="row.name">{{ row.name }}</p>
+          <p v-else-if="row.category && !nested" class="rr-cat">{{ row.category.name }}</p>
+        </div>
+
+        <TorrentDetailQualityChips :name="row.name" :tags="row.tags ?? null" compact class="rr-chips" />
+
+        <span class="rr-size rr-num">{{ formatSize(row.size) }}</span>
+
+        <span class="rr-swarm rr-num" :title="swarmTitle(row)">
+          <span class="rr-seed"><Icon name="ph:arrow-up-bold" aria-hidden="true" />{{ row.stats.seeders }}</span>
+          <span class="rr-leech"><Icon name="ph:arrow-down-bold" aria-hidden="true" />{{ row.stats.leechers }}</span>
+        </span>
+
+        <span class="rr-by rr-col-by">
+          <NuxtLink v-if="row.uploader?.username" :to="`/users/${row.uploader.id}`" class="rr-by-link">
+            {{ row.uploader.username }}
+          </NuxtLink>
+          <!-- Un membre qui publie anonymement n'est pas un compte supprimé :
+               l'API le dit par `uploaderAnonymous`, la ligne doit le dire aussi. -->
+          <span v-else-if="row.uploaderAnonymous" class="rr-by-none" :title="t('torrents.detail.uploaderAnonymousTooltip')">
+            {{ t('torrents.detail.uploaderAnonymous') }}
+          </span>
+          <span v-else class="rr-by-none">—</span>
+        </span>
+
+        <!-- Relatif à lire, exact au survol : « il y a 3 jours » ne dit pas le jour. -->
+        <time class="rr-age rr-col-age" :datetime="row.createdAt" :title="formatDate(row.createdAt)">{{ formatAge(row.createdAt) }}</time>
+
+        <button
+          v-if="row.viewerFavorited !== undefined"
+          type="button"
+          class="rr-ico rr-fav"
+          :class="{ 'is-on': isFavorited(row) }"
+          :aria-pressed="isFavorited(row)"
+          :aria-label="isFavorited(row) ? t('components.torrentTable.unfavorite') : t('components.torrentTable.favorite')"
+          @click.stop="toggleFavorite(row)"
+        >
+          <Icon :name="isFavorited(row) ? 'ph:star-fill' : 'ph:star-bold'" aria-hidden="true" />
+        </button>
+        <span v-else />
+        <a
+          class="rr-ico rr-dl"
+          :href="downloadHref(row)"
+          download
+          :aria-label="t('search.rows.download', { name: row.name })"
+        >
+          <Icon name="ph:download-simple-bold" aria-hidden="true" />
+        </a>
+      </li>
+    </ul>
+    <p v-if="torrents.length && showHeader" class="rr-keys" aria-hidden="true">{{ t('search.rows.shortcuts') }}</p>
+  </div>
+</template>
+
+<style scoped>
+.rr {
+  container-type: inline-size;
+  border: 1px solid rgb(var(--line-default) / 1);
+  border-radius: var(--radius-lg);
+  background: rgb(var(--bg-surface) / 1);
+  overflow: hidden;
+}
+.rr--pinned {
+  border-color: rgb(var(--accent-warm) / 0.35);
+  background: rgb(var(--accent-warm) / 0.05);
+}
+.rr-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
+/* ── La grille, partagée par l'en-tête et les lignes ────────────────────── */
+.rr-head,
+.rr-row {
+  display: grid;
+  grid-template-columns: 0.5rem minmax(0, 1fr) minmax(0, 17rem) 5.25rem 5.75rem 7rem 4.75rem 2rem 2rem;
+  gap: 0 0.85rem;
+  align-items: center;
+  padding: 0.7rem 0.85rem 0.7rem 0.65rem;
+}
+.rr-head {
+  padding-top: 0.45rem;
+  padding-bottom: 0.45rem;
+  border-bottom: 1px solid rgb(var(--line-default) / 1);
+  font-family: var(--font-mono);
+  font-size: 0.625rem;
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  color: rgb(var(--fg-muted) / 1);
+  background: rgb(var(--bg-inset) / 0.6);
+}
+.rr-row {
+  position: relative;
+  border-bottom: 1px solid rgb(var(--line-default) / 0.7);
+  transition: background-color var(--dur-2) var(--ease-standard);
+}
+.rr-row:last-child {
+  border-bottom: 0;
+}
+.rr-row:hover,
+.rr-row:focus-within {
+  background: rgb(var(--bg-hover) / 0.6);
+}
+.rr--dense .rr-row {
+  padding-top: 0.35rem;
+  padding-bottom: 0.35rem;
+}
+.rr--dense .rr-name,
+.rr--dense .rr-cat {
+  display: none;
+}
+.rr--dense .rr-chips {
+  --qc-scale: 0.92;
+}
+
+/* ── La pastille d'état ──────────────────────────────────────────────────── */
+.rr-pip {
+  position: relative;
+  z-index: 1;
+  width: 0.5rem;
+  height: 0.5rem;
+  border-radius: 50%;
+  background: rgb(var(--fg-faint) / 1);
+}
+.rr-row[data-state='hot'] .rr-pip {
+  background: rgb(var(--online) / 1);
+  box-shadow: 0 0 0 3px rgb(var(--online) / 0.18);
+}
+.rr-row[data-state='ok'] .rr-pip {
+  background: rgb(var(--online) / 0.8);
+}
+.rr-row[data-state='thin'] .rr-pip {
+  background: rgb(var(--warning) / 1);
+}
+.rr-row[data-state='dead'] .rr-pip {
+  background: transparent;
+  box-shadow: inset 0 0 0 1.5px rgb(var(--danger) / 0.7);
+}
+
+/* ── La colonne principale ───────────────────────────────────────────────── */
+.rr-main {
+  min-width: 0;
+  display: grid;
+  gap: 0.15rem;
+}
+.rr-l1 {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 0.2rem 0.5rem;
+  min-width: 0;
+}
+.rr-title {
+  font-weight: 600;
+  font-size: 0.875rem;
+  color: rgb(var(--fg-strong) / 1);
+  text-decoration: none;
+  /* Deux lignes au plus, puis coupé : un titre en points de suspension après
+     quarante caractères perdait le tome, la saison ou le groupe. */
+  display: -webkit-box;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: 2;
+  line-clamp: 2;
+  overflow: hidden;
+  overflow-wrap: anywhere;
+  max-width: 100%;
+  border-radius: var(--radius-xs);
+}
+.rr-title::after {
+  /* La ligne entière ouvre la fiche, sans emballer neuf cellules dans un lien. */
+  content: '';
+  position: absolute;
+  inset: 0;
+  z-index: 0;
+}
+.rr-title--name {
+  font-family: var(--font-mono);
+  font-weight: 500;
+  font-size: 0.8125rem;
+  letter-spacing: -0.01em;
+}
+.rr-year {
+  font-weight: 400;
+  color: rgb(var(--fg-muted) / 1);
+}
+.rr-unit {
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  padding: 0.05rem 0.4rem;
+  border-radius: var(--radius-xs);
+  background: rgb(var(--bg-inset) / 1);
+  color: rgb(var(--fg-default) / 1);
+}
+.rr-name,
+.rr-cat {
+  margin: 0;
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  color: rgb(var(--fg-muted) / 1);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.rr-cat {
+  font-family: inherit;
+}
+.rr-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.2rem;
+  height: 1.1rem;
+  padding: 0 0.4rem;
+  border-radius: var(--radius-pill);
+  font-size: 0.625rem;
+  font-weight: 600;
+  letter-spacing: 0.02em;
+  text-transform: uppercase;
+  line-height: 1;
+}
+.rr-badge :deep(svg) {
+  width: 0.6rem;
+  height: 0.6rem;
+}
+.rr-badge--free {
+  background: rgb(var(--online) / 0.16);
+  color: rgb(var(--online) / 1);
+}
+.rr-badge--old {
+  background: rgb(var(--bg-inset) / 1);
+  color: rgb(var(--fg-muted) / 1);
+}
+.rr-badge--taken {
+  background: rgb(var(--info) / 0.14);
+  color: rgb(var(--info) / 1);
+}
+.rr-row.is-old .rr-title,
+.rr-row.is-old .rr-name {
+  color: rgb(var(--fg-muted) / 1);
+}
+/* Une autre version d'un contenu déjà en tête : en retrait, le filet de gauche le dit. */
+.rr-row--version {
+  background: rgb(var(--bg-inset) / 0.4);
+  box-shadow: inset 3px 0 0 rgb(var(--line-strong) / 1);
+}
+/* Le titre d'œuvre déjà lu sur la ligne d'avant s'efface : un registre, pas une litanie. */
+.rr-row--repeat .rr-title:not(.rr-title--name) {
+  font-weight: 500;
+  color: rgb(var(--fg-muted) / 1);
+}
+.rr-row--repeat .rr-year {
+  color: rgb(var(--fg-faint) / 1);
+}
+/* De l'information cachée mérite une couleur : la pastille des versions est dorée. */
+.rr-versions {
+  position: relative;
+  z-index: 1;
+  display: inline-flex;
+  align-items: center;
+  height: 1.2rem;
+  padding: 0 0.5rem;
+  border: 1px solid rgb(var(--accent-warm) / 0.45);
+  border-radius: var(--radius-pill);
+  background: rgb(var(--accent-warm) / 0.1);
+  font-size: 0.625rem;
+  font-weight: 600;
+  color: rgb(var(--accent-warm-text) / 1);
+  white-space: nowrap;
+}
+.rr-versions:hover {
+  background: rgb(var(--accent-warm) / 0.2);
+}
+/* Dans une carte d'œuvre : le nom de fichier en tête, les chiffres à droite
+   (taille, essaim, âge), et les qualités en une ligne dessous, valeurs seules.
+   L'uploadeur reste hors champ ; l'unité aussi, l'en-tête au-dessus la nomme. */
+.rr--nested {
+  border-radius: var(--radius-md);
+}
+.rr--nested .rr-row {
+  grid-template-columns: 0.5rem minmax(0, 1fr) 5rem 5rem 6.75rem 2rem 2rem;
+  grid-template-areas:
+    'pip main size swarm age fav dl'
+    'pip chips chips chips chips chips chips';
+  row-gap: 0.3rem;
+  padding-top: 0.5rem;
+  padding-bottom: 0.5rem;
+}
+.rr--nested .rr-pip {
+  grid-area: pip;
+  align-self: start;
+  margin-top: 0.45rem;
+}
+.rr--nested .rr-main {
+  grid-area: main;
+}
+.rr--nested .rr-chips {
+  grid-area: chips;
+}
+.rr--nested .rr-size {
+  grid-area: size;
+}
+.rr--nested .rr-swarm {
+  grid-area: swarm;
+}
+.rr--nested .rr-age {
+  grid-area: age;
+}
+.rr--nested .rr-fav {
+  grid-area: fav;
+}
+.rr--nested .rr-dl {
+  grid-area: dl;
+}
+.rr--nested .rr-col-by,
+.rr--nested .rr-unit {
+  display: none;
+}
+.rr--nested .rr-title--name {
+  font-size: 0.8125rem;
+}
+/* Les puces sans leur plaque : la teinte dit la famille, la valeur suffit.
+   Trois rangées de puces dans une colonne étroite doublaient la hauteur de la ligne. */
+.rr--nested .rr-chips :deep(.qc-k) {
+  display: none;
+}
+.rr--nested .rr-chips :deep(.qc-chip) {
+  min-height: 1.25rem;
+  border-left-width: 2px;
+}
+.rr--nested .rr-chips :deep(.qc-v) {
+  padding-inline: 0.35rem;
+}
+/* En densité compacte, l'audio et le HDR n'ont plus de place : résolution, source et codec suffisent. */
+.rr--dense .rr-chips :deep(.qc-item[data-slot='audio']),
+.rr--dense .rr-chips :deep(.qc-item[data-slot='hdr']) {
+  display: none;
+}
+
+/* ── Les cellules ────────────────────────────────────────────────────────── */
+.rr-chips {
+  min-width: 0;
+  position: relative;
+  z-index: 1;
+}
+.rr-num {
+  font-variant-numeric: tabular-nums;
+  text-align: right;
+}
+.rr-size {
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  color: rgb(var(--fg-default) / 1);
+  white-space: nowrap;
+}
+.rr-swarm {
+  position: relative;
+  z-index: 1;
+  display: inline-flex;
+  justify-content: flex-end;
+  gap: 0.5rem;
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  white-space: nowrap;
+}
+.rr-seed,
+.rr-leech {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.1rem;
+}
+.rr-seed {
+  color: rgb(var(--online) / 1);
+}
+.rr-leech {
+  color: rgb(var(--fg-muted) / 1);
+}
+.rr-row[data-state='dead'] .rr-seed {
+  color: rgb(var(--danger) / 1);
+}
+.rr-swarm :deep(svg) {
+  width: 0.65rem;
+  height: 0.65rem;
+}
+.rr-by {
+  min-width: 0;
+  font-size: 0.75rem;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.rr-by-link {
+  position: relative;
+  z-index: 1;
+  color: rgb(var(--fg-default) / 1);
+  text-decoration: none;
+}
+.rr-by-link:hover {
+  color: rgb(var(--fg-strong) / 1);
+  text-decoration: underline;
+}
+.rr-by-none {
+  color: rgb(var(--fg-faint) / 1);
+}
+.rr-age {
+  /* Au-dessus du lien étiré qui couvre la ligne : sinon le survol atteint le
+     lien, et l'infobulle montre le nom du fichier au lieu de la date. */
+  position: relative;
+  z-index: 1;
+  font-size: 0.75rem;
+  color: rgb(var(--fg-muted) / 1);
+  white-space: nowrap;
+}
+.rr-ico {
+  position: relative;
+  z-index: 1;
+  display: inline-grid;
+  place-items: center;
+  width: 2rem;
+  height: 2rem;
+  border-radius: var(--radius-sm);
+  color: rgb(var(--fg-muted) / 1);
+  transition:
+    background-color var(--dur-1) var(--ease-standard),
+    color var(--dur-1) var(--ease-standard),
+    transform var(--dur-1) var(--ease-standard);
+}
+.rr-ico :deep(svg) {
+  width: 1rem;
+  height: 1rem;
+}
+.rr-ico:hover {
+  background: rgb(var(--bg-inset) / 1);
+  color: rgb(var(--fg-strong) / 1);
+}
+.rr-ico:active {
+  transform: scale(0.92);
+}
+.rr-fav.is-on {
+  color: rgb(var(--accent-warm-text) / 1);
+}
+.rr-dl:hover {
+  color: rgb(var(--accent-warm-text) / 1);
+}
+.rr-keys {
+  margin: 0;
+  padding: 0.35rem 0.85rem;
+  border-top: 1px solid rgb(var(--line-default) / 0.7);
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  letter-spacing: 0.02em;
+  color: rgb(var(--fg-muted) / 1);
+}
+@media (pointer: coarse) {
+  .rr-keys {
+    display: none;
+  }
+}
+
+/* ── Quand la place manque : l'uploadeur, puis les puces sous le titre, puis l'empilement ── */
+@container (max-width: 64rem) {
+  .rr-head,
+  .rr-row {
+    grid-template-columns: 0.5rem minmax(0, 1fr) minmax(0, 15rem) 5.25rem 5.75rem 4.75rem 2rem 2rem;
+  }
+  .rr-col-by {
+    display: none;
+  }
+}
+/* Le titre étouffait entre le filet et seize rem de puces : les puces passent dessous. */
+@container (max-width: 56rem) {
+  .rr-head {
+    grid-template-columns: 0.5rem minmax(0, 1fr) 5.25rem 5.75rem 4.75rem 2rem 2rem;
+  }
+  .rr-head > :nth-child(3) {
+    display: none;
+  }
+  .rr-row {
+    grid-template-columns: 0.5rem minmax(0, 1fr) 5.25rem 5.75rem 4.75rem 2rem 2rem;
+    grid-template-areas:
+      'pip main size swarm age fav dl'
+      'pip chips chips chips chips chips chips';
+    row-gap: 0.35rem;
+  }
+  .rr-pip {
+    grid-area: pip;
+    align-self: start;
+    margin-top: 0.5rem;
+  }
+  .rr-main {
+    grid-area: main;
+  }
+  .rr-chips {
+    grid-area: chips;
+  }
+  .rr-size {
+    grid-area: size;
+  }
+  .rr-swarm {
+    grid-area: swarm;
+  }
+  .rr-age {
+    grid-area: age;
+  }
+  .rr-fav {
+    grid-area: fav;
+  }
+  .rr-dl {
+    grid-area: dl;
+  }
+  .rr-by {
+    display: none;
+  }
+}
+@container (max-width: 46rem) {
+  .rr-head {
+    display: none;
+  }
+  /* La variante imbriquée aussi : sa règle à 56rem (six colonnes) est plus
+     spécifique que `.rr-row` et laissait 0px au titre dans une carte à 390. */
+  .rr-row,
+  .rr--nested .rr-row {
+    grid-template-columns: 0.5rem minmax(0, 1fr) 2.5rem 2.5rem;
+    grid-template-areas:
+      'pip main fav dl'
+      'pip chips chips chips'
+      'pip meta meta meta';
+    row-gap: 0.4rem;
+    padding: 0.85rem 0.75rem 0.85rem 0.65rem;
+  }
+  .rr-pip {
+    grid-area: pip;
+    align-self: start;
+    margin-top: 0.45rem;
+  }
+  .rr-main {
+    grid-area: main;
+  }
+  .rr-chips {
+    grid-area: chips;
+  }
+  .rr-fav {
+    grid-area: fav;
+  }
+  .rr-dl {
+    grid-area: dl;
+  }
+  .rr-size,
+  .rr-swarm,
+  .rr-age,
+  .rr--nested .rr-size,
+  .rr--nested .rr-swarm,
+  .rr--nested .rr-age {
+    grid-area: meta;
+    text-align: left;
+    justify-content: flex-start;
+  }
+  .rr-size {
+    justify-self: start;
+  }
+  .rr-swarm {
+    justify-self: center;
+  }
+  .rr-age {
+    justify-self: end;
+  }
+  .rr-ico {
+    width: 2.5rem;
+    height: 2.5rem;
+  }
+  .rr--dense .rr-name {
+    display: block;
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  .rr-row,
+  .rr-ico {
+    transition: none;
+  }
+}
+</style>
diff --git a/apps/web/app/components/search/TokenSearch.vue b/apps/web/app/components/search/TokenSearch.vue
new file mode 100644
index 00000000..c243d4a1
--- /dev/null
+++ b/apps/web/app/components/search/TokenSearch.vue
@@ -0,0 +1,691 @@
+<script setup lang="ts">
+/**
+ * La barre du catalogue : un champ qui comprend ce qu'on lui tape.
+ *
+ * « frieren 1080p x265 vostfr » : les trois qualificatifs se détachent en
+ * puces au premier espace, le titre reste dans le champ. Chaque puce est un
+ * filtre typé (voir `utils/searchTokens.ts`) ; un lien IMDb/TMDb/TVDB collé
+ * part vers le filtre d'identifiant de la page, comme avant. Retour arrière
+ * sur un champ vide reprend la dernière puce ; `/` ramène le focus ici de
+ * n'importe où.
+ *
+ * Sous le champ, quand il a le focus : les ŒUVRES que le texte désigne (avant
+ * les releases — c'est ce qu'on cherche le plus souvent), les formes que la
+ * barre comprend, et les recherches récentes. Un combobox au sens ARIA : les
+ * flèches parcourent, Entrée choisit, Échap ferme.
+ */
+import { detectMediaId, type DetectedMediaId } from '~/utils/mediaIdDetect';
+import { mergeTokens, parseSearchInput, tokenLabel, type SearchToken } from '~/utils/searchTokens';
+
+export interface SuggestedWork {
+  key: string;
+  source: 'tmdb' | 'igdb' | 'openlibrary' | 'solo';
+  externalId: string;
+  title: string;
+  year: number | null;
+  posterUrl: string | null;
+  releaseCount: number;
+}
+export interface RecentSearch {
+  label: string;
+  query: Record<string, string>;
+}
+
+const props = withDefaults(
+  defineProps<{
+    modelValue: string;
+    tokens: SearchToken[];
+    loading?: boolean;
+    placeholder?: string;
+    recent?: RecentSearch[];
+    /** Les fiches ouvertes récemment, gardées par le navigateur. */
+    recentlyViewed?: Array<{ hash: string; title: string }>;
+  }>(),
+  { loading: false, placeholder: '', recent: () => [], recentlyViewed: () => [] },
+);
+const emit = defineEmits<{
+  'update:modelValue': [value: string];
+  'update:tokens': [tokens: SearchToken[]];
+  search: [query: string];
+  mediaIdSearch: [detected: DetectedMediaId];
+  pickWork: [work: SuggestedWork];
+  pickRecent: [query: Record<string, string>];
+}>();
+
+const { t } = useI18n();
+const inputRef = ref<HTMLInputElement | null>(null);
+const draft = ref(props.modelValue);
+watch(
+  () => props.modelValue,
+  (v) => {
+    if (v !== draft.value.trim()) draft.value = v;
+  },
+);
+
+const kindLabel = (kind: SearchToken['kind']) => t(`search.tokens.${kind}`);
+
+/* ── Ce que la saisie devient ─────────────────────────────────────────────── */
+function commit(keepTail: boolean): { text: string; media: DetectedMediaId | null } {
+  const value = draft.value;
+  const words = value.split(/\s+/).filter(Boolean);
+  const tail = keepTail && !/\s$/.test(value) ? words.pop() ?? '' : '';
+  const { tokens, text } = parseSearchInput(words.join(' '));
+  let media: DetectedMediaId | null = null;
+  const chips: SearchToken[] = [];
+  for (const tk of tokens) {
+    if (tk.kind === 'imdb' || tk.kind === 'tmdb' || tk.kind === 'tvdb') {
+      media = media ?? detectMediaId(tk.raw);
+      continue;
+    }
+    chips.push(tk);
+  }
+  if (chips.length) emit('update:tokens', mergeTokens([...props.tokens, ...chips]));
+  const rest = [text, tail].filter(Boolean).join(' ');
+  draft.value = keepTail && /\s$/.test(value) && rest ? `${rest} ` : rest;
+  emit('update:modelValue', rest.trim());
+  return { text: rest.trim(), media };
+}
+
+function onInput(e: Event) {
+  draft.value = (e.target as HTMLInputElement).value;
+  active.value = -1;
+  open.value = true;
+  if (/\s$/.test(draft.value)) {
+    // Un lien collé puis un espace : il part vers le filtre d'identifiant tout
+    // de suite, sinon il disparaîtrait du champ sans rien filtrer.
+    const { media } = commit(true);
+    if (media) emit('mediaIdSearch', media);
+    return;
+  }
+  emit('update:modelValue', draft.value.trim());
+}
+
+function onEnter() {
+  if (open.value && active.value >= 0) {
+    pick(active.value);
+    return;
+  }
+  const { text, media } = commit(false);
+  close();
+  if (media) {
+    emit('mediaIdSearch', media);
+    return;
+  }
+  emit('search', text);
+}
+
+function onBackspace(e: KeyboardEvent) {
+  if (draft.value !== '' || props.tokens.length === 0) return;
+  e.preventDefault();
+  emit('update:tokens', props.tokens.slice(0, -1));
+}
+
+function remove(index: number) {
+  emit('update:tokens', props.tokens.filter((_, i) => i !== index));
+  inputRef.value?.focus();
+}
+
+function clearAll() {
+  draft.value = '';
+  emit('update:modelValue', '');
+  emit('update:tokens', []);
+  inputRef.value?.focus();
+}
+
+function onGlobalKey(e: KeyboardEvent) {
+  if (e.key !== '/' || e.metaKey || e.ctrlKey || e.altKey || e.isComposing) return;
+  const el = document.activeElement as HTMLElement | null;
+  if (el && (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA' || el.isContentEditable)) return;
+  e.preventDefault();
+  // La barre de l'en-tête écoute la même touche : sur cette page, c'est ici
+  // que « / » doit mener — écouté en capture, et la propagation s'arrête.
+  e.stopImmediatePropagation();
+  inputRef.value?.focus();
+}
+onMounted(() => document.addEventListener('keydown', onGlobalKey, { capture: true }));
+onBeforeUnmount(() => {
+  document.removeEventListener('keydown', onGlobalKey, { capture: true });
+  if (timer) clearTimeout(timer);
+  aborter?.abort();
+});
+
+const hasContent = computed(() => props.tokens.length > 0 || draft.value.trim() !== '');
+
+/* ── Les suggestions ──────────────────────────────────────────────────────── */
+const open = ref(false);
+const active = ref(-1);
+const works = ref<SuggestedWork[]>([]);
+const worksFor = ref('');
+const loadingWorks = ref(false);
+let timer: ReturnType<typeof setTimeout> | null = null;
+let aborter: AbortController | null = null;
+// `useId` : le même identifiant au rendu serveur et à l'hydratation.
+const listId = `ts-sugg-${useId()}`;
+
+/** Le texte cherché, sans les mots qui deviendront des puces. */
+const searchText = computed(() => parseSearchInput(draft.value).text.trim());
+
+async function fetchWorks(text: string) {
+  aborter?.abort();
+  const ctl = new AbortController();
+  aborter = ctl;
+  loadingWorks.value = true;
+  try {
+    const res = await $fetch<{
+      groups: Array<{
+        key: string;
+        source: SuggestedWork['source'];
+        externalId: string;
+        leadName: string;
+        releaseCount: number;
+        work?: { title: string; year: number | null; posterUrl: string | null } | null;
+      }>;
+    }>('/api/torrents/groups', { query: { search: text, limit: 4, sources: 'local' }, signal: ctl.signal });
+    if (ctl.signal.aborted) return;
+    works.value = res.groups.map((g) => ({
+      key: g.key,
+      source: g.source,
+      externalId: g.externalId,
+      title: g.work?.title || g.leadName,
+      year: g.work?.year ?? null,
+      posterUrl: g.work?.posterUrl ?? null,
+      releaseCount: g.releaseCount,
+    }));
+    worksFor.value = text;
+  } catch {
+    if (!ctl.signal.aborted) works.value = [];
+  } finally {
+    if (aborter === ctl) loadingWorks.value = false;
+  }
+}
+watch(searchText, (text) => {
+  if (timer) clearTimeout(timer);
+  if (text.length < 2) {
+    works.value = [];
+    worksFor.value = '';
+    aborter?.abort();
+    loadingWorks.value = false;
+    return;
+  }
+  timer = setTimeout(() => void fetchWorks(text), 250);
+});
+
+type Option =
+  | { kind: 'work'; id: string; work: SuggestedWork }
+  | { kind: 'recent'; id: string; recent: RecentSearch };
+const options = computed<Option[]>(() => {
+  const out: Option[] = [];
+  if (searchText.value.length >= 2) {
+    for (const w of works.value) out.push({ kind: 'work', id: `${listId}-w-${w.key}`, work: w });
+  } else {
+    props.recent.forEach((r, i) => out.push({ kind: 'recent', id: `${listId}-r-${i}`, recent: r }));
+  }
+  return out;
+});
+const showHints = computed(() => searchText.value.length < 2);
+const panelVisible = computed(
+  () => open.value && (options.value.length > 0 || showHints.value || loadingWorks.value || searchText.value.length >= 2),
+);
+const activeId = computed(() => (active.value >= 0 ? options.value[active.value]?.id : undefined));
+
+function close() {
+  open.value = false;
+  active.value = -1;
+}
+function onFocus() {
+  open.value = true;
+}
+function onBlur() {
+  // Laisse le clic sur une option arriver avant de fermer.
+  setTimeout(() => close(), 120);
+}
+function move(delta: number) {
+  if (!options.value.length) return;
+  open.value = true;
+  const n = options.value.length;
+  active.value = ((active.value + delta) % n + n) % n;
+}
+function pick(index: number) {
+  const opt = options.value[index];
+  if (!opt) return;
+  close();
+  if (opt.kind === 'work') {
+    emit('pickWork', opt.work);
+    draft.value = '';
+    emit('update:modelValue', '');
+  } else {
+    emit('pickRecent', opt.recent.query);
+  }
+}
+</script>
+
+<template>
+  <div class="ts">
+    <div class="ts-field" @click="inputRef?.focus()">
+      <Icon v-if="loading" name="ph:circle-notch" class="ts-ico ts-ico--spin" aria-hidden="true" />
+      <Icon v-else name="ph:magnifying-glass" class="ts-ico" aria-hidden="true" />
+      <ul v-if="tokens.length" class="ts-chips" :aria-label="t('search.tokens.active')">
+        <li v-for="(tk, i) in tokens" :key="`${tk.kind}-${tk.value}`" class="ts-chip" :data-kind="tk.kind">
+          <span class="ts-chip-k">{{ kindLabel(tk.kind) }}</span>
+          <span class="ts-chip-v">{{ tokenLabel(tk) }}</span>
+          <button
+            type="button"
+            class="ts-chip-x"
+            :aria-label="t('search.tokens.remove', { label: kindLabel(tk.kind), value: tokenLabel(tk) })"
+            @click.stop="remove(i)"
+          >
+            <Icon name="ph:x-bold" aria-hidden="true" />
+          </button>
+        </li>
+      </ul>
+      <input
+        ref="inputRef"
+        :value="draft"
+        type="text"
+        class="ts-input"
+        autocomplete="off"
+        spellcheck="false"
+        role="combobox"
+        aria-autocomplete="list"
+        :aria-expanded="panelVisible"
+        :aria-controls="listId"
+        :aria-activedescendant="activeId"
+        :aria-label="t('search.tokens.inputLabel')"
+        :placeholder="tokens.length ? '' : placeholder || t('search.searchPlaceholder')"
+        @input="onInput"
+        @focus="onFocus"
+        @blur="onBlur"
+        @keydown.enter.prevent="onEnter"
+        @keydown.backspace="onBackspace"
+        @keydown.down.prevent="move(1)"
+        @keydown.up.prevent="move(-1)"
+        @keydown.esc="close"
+      />
+      <kbd v-if="!hasContent" class="ts-kbd" aria-hidden="true">/</kbd>
+      <button
+        v-else
+        type="button"
+        class="ts-clear"
+        :aria-label="t('search.clear')"
+        @click.stop="clearAll"
+      >
+        <Icon name="ph:x" aria-hidden="true" />
+      </button>
+    </div>
+
+    <!-- L'id est sur le panneau, toujours dans le DOM (v-show) : `aria-controls`
+         du champ pointe vers quelque chose même quand aucune liste n'est rendue. -->
+    <div v-show="panelVisible" :id="listId" class="ts-sugg" @mousedown.prevent>
+      <template v-if="!showHints">
+        <p class="ts-sugg-h">{{ t('search.suggest.understood') }}</p>
+        <ul role="listbox" class="ts-sugg-list" :aria-label="t('search.suggest.understood')">
+          <li
+            v-for="(opt, i) in options"
+            :id="opt.id"
+            :key="opt.id"
+            role="option"
+            class="ts-sg"
+            :class="{ 'ts-sg--active': i === active }"
+            :aria-selected="i === active"
+            @click="pick(i)"
+            @mousemove="active = i"
+          >
+            <template v-if="opt.kind === 'work'">
+              <TorrentPosterHover class="ts-sg-pst" :src="opt.work.posterUrl" :alt="opt.work.title" fallback-icon="ph:film-slate-bold" />
+              <span class="ts-sg-main">
+                <span class="ts-sg-title">{{ opt.work.title }}<span v-if="opt.work.year" class="ts-sg-year"> {{ opt.work.year }}</span></span>
+                <span class="ts-sg-meta">{{ t('search.suggest.work', opt.work.releaseCount) }}</span>
+              </span>
+            </template>
+          </li>
+        </ul>
+        <p v-if="loadingWorks && !options.length" class="ts-sugg-note">{{ t('search.suggest.loading') }}</p>
+        <p v-else-if="!options.length && worksFor === searchText" class="ts-sugg-note">{{ t('search.suggest.none', { q: searchText }) }}</p>
+      </template>
+      <template v-else>
+        <p class="ts-sugg-h">{{ t('search.suggest.howTitle') }}</p>
+        <ul class="ts-hints" aria-hidden="true">
+          <li><span class="ts-hint-tok"><b>{{ t('search.tokens.season') }}</b>1</span>{{ t('search.suggest.hints.unit') }}</li>
+          <li><span class="ts-hint-tok"><b>{{ t('search.tokens.tmdb') }}</b>id</span>{{ t('search.suggest.hints.link') }}</li>
+          <li><span class="ts-hint-tok"><b>{{ t('search.tokens.uploader') }}</b>@…</span>{{ t('search.suggest.hints.uploader') }}</li>
+        </ul>
+        <template v-if="recentlyViewed.length">
+          <p class="ts-sugg-h">{{ t('search.suggest.viewed') }}</p>
+          <ul class="ts-sugg-list">
+            <li v-for="v in recentlyViewed" :key="v.hash" class="ts-sg ts-sg--recent">
+              <Icon name="ph:eye" class="ts-sg-ico" aria-hidden="true" />
+              <NuxtLink class="ts-sg-title ts-sg-link" :to="`/torrents/${v.hash}`">{{ v.title }}</NuxtLink>
+            </li>
+          </ul>
+        </template>
+        <template v-if="options.length">
+          <p class="ts-sugg-h">{{ t('search.suggest.recent') }}</p>
+          <ul role="listbox" class="ts-sugg-list" :aria-label="t('search.suggest.recent')">
+            <li
+              v-for="(opt, i) in options"
+              :id="opt.id"
+              :key="opt.id"
+              role="option"
+              class="ts-sg ts-sg--recent"
+              :class="{ 'ts-sg--active': i === active }"
+              :aria-selected="i === active"
+              @click="pick(i)"
+              @mousemove="active = i"
+            >
+              <Icon name="ph:clock-counter-clockwise" class="ts-sg-ico" aria-hidden="true" />
+              <span class="ts-sg-title">{{ opt.kind === 'recent' ? opt.recent.label : '' }}</span>
+            </li>
+          </ul>
+        </template>
+      </template>
+    </div>
+
+  </div>
+</template>
+
+<style scoped>
+.ts {
+  position: relative;
+  display: grid;
+  gap: 0.45rem;
+}
+.ts-field {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.35rem 0.4rem;
+  min-height: 3.5rem;
+  padding: 0.5rem 0.75rem 0.5rem 0.95rem;
+  border: 1px solid rgb(var(--line-field) / 1);
+  border-radius: var(--radius-lg);
+  background: rgb(var(--bg-surface) / 1);
+  cursor: text;
+  transition:
+    border-color var(--dur-2) var(--ease-standard),
+    box-shadow var(--dur-2) var(--ease-standard),
+    background-color var(--dur-2) var(--ease-standard);
+}
+.ts-field:focus-within {
+  border-color: rgb(var(--accent-warm) / 0.7);
+  background: rgb(var(--bg-elevated) / 1);
+  box-shadow: 0 0 0 4px rgb(var(--accent-warm) / 0.12);
+}
+.ts-ico {
+  flex: none;
+  width: 1.15rem;
+  height: 1.15rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+.ts-field:focus-within .ts-ico {
+  color: rgb(var(--accent-warm-text) / 1);
+}
+.ts-ico--spin {
+  animation: ts-spin 0.9s linear infinite;
+}
+@keyframes ts-spin {
+  to {
+    transform: rotate(1turn);
+  }
+}
+.ts-chips {
+  display: contents;
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+.ts-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  height: 1.75rem;
+  padding: 0 0.25rem 0 0.6rem;
+  border-radius: var(--radius-pill);
+  background: rgb(var(--accent-warm) / 0.12);
+  border: 1px solid rgb(var(--accent-warm) / 0.35);
+  color: rgb(var(--fg-strong) / 1);
+  font-size: 0.75rem;
+  line-height: 1;
+  white-space: nowrap;
+  animation: ts-chip-in var(--dur-3) var(--ease-emphasis) both;
+}
+@keyframes ts-chip-in {
+  from {
+    opacity: 0;
+    transform: translateY(0.25rem) scale(0.96);
+  }
+}
+.ts-chip-k {
+  font-family: var(--font-mono);
+  font-size: 0.625rem;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: rgb(var(--accent-warm-text) / 1);
+}
+.ts-chip-v {
+  font-weight: 600;
+}
+.ts-chip-x {
+  display: inline-grid;
+  place-items: center;
+  width: 1.35rem;
+  height: 1.35rem;
+  border-radius: 50%;
+  color: rgb(var(--fg-muted) / 1);
+  transition: background-color var(--dur-1) var(--ease-standard), color var(--dur-1) var(--ease-standard);
+}
+.ts-chip-x:hover {
+  background: rgb(var(--accent-warm) / 0.25);
+  color: rgb(var(--fg-strong) / 1);
+}
+.ts-chip-x :deep(svg) {
+  width: 0.7rem;
+  height: 0.7rem;
+}
+.ts-input {
+  flex: 1 1 10rem;
+  min-width: 8rem;
+  height: 2.25rem;
+  background: transparent;
+  border: 0;
+  outline: none;
+  font-size: 1rem;
+  color: rgb(var(--fg-strong) / 1);
+}
+.ts-input::placeholder {
+  color: rgb(var(--fg-faint) / 1);
+}
+.ts-kbd {
+  flex: none;
+  padding: 0.15rem 0.5rem;
+  border: 1px solid rgb(var(--line-default) / 1);
+  border-radius: var(--radius-sm);
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  color: rgb(var(--fg-muted) / 1);
+  background: rgb(var(--bg-inset) / 1);
+}
+.ts-clear {
+  flex: none;
+  display: inline-grid;
+  place-items: center;
+  width: 2.25rem;
+  height: 2.25rem;
+  border-radius: 50%;
+  color: rgb(var(--fg-muted) / 1);
+  transition: background-color var(--dur-1) var(--ease-standard), color var(--dur-1) var(--ease-standard);
+}
+.ts-clear:hover {
+  background: rgb(var(--bg-hover) / 1);
+  color: rgb(var(--fg-strong) / 1);
+}
+.ts-clear :deep(svg) {
+  width: 1rem;
+  height: 1rem;
+}
+
+/* ── Le panneau de suggestions ───────────────────────────────────────────── */
+/* Sous le champ, pas dessus : le panneau se posait à `100% - 1.4rem` du temps
+   où une ligne d'aide occupait ce bas de bloc ; elle est partie, lui restait. */
+.ts-sugg {
+  position: absolute;
+  top: calc(100% + 0.4rem);
+  left: 0;
+  right: 0;
+  z-index: 30;
+  display: grid;
+  gap: 0.25rem;
+  padding: 0.6rem 0.5rem 0.5rem;
+  border: 1px solid rgb(var(--line-default) / 1);
+  border-radius: var(--radius-lg);
+  background: rgb(var(--bg-elevated) / 1);
+  box-shadow: 0 24px 48px -24px rgb(var(--shadow-color) / var(--shadow-strength));
+  animation: ts-sugg-in var(--dur-3) var(--ease-emphasis) both;
+}
+@keyframes ts-sugg-in {
+  from {
+    opacity: 0;
+    transform: translateY(-0.25rem);
+  }
+}
+.ts-sugg-h {
+  margin: 0.2rem 0.5rem 0;
+  font-family: var(--font-mono);
+  font-size: 0.62rem;
+  font-weight: 700;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted) / 1);
+}
+.ts-sugg-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: grid;
+}
+.ts-sg {
+  display: flex;
+  align-items: center;
+  gap: 0.65rem;
+  min-height: 2.5rem;
+  padding: 0.3rem 0.5rem;
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+}
+.ts-sg--active {
+  background: rgb(var(--bg-hover) / 1);
+}
+.ts-sg-pst {
+  flex: none;
+  width: 32px;
+  height: 48px;
+  border-radius: var(--radius-xs);
+  overflow: hidden;
+}
+.ts-sg-ico {
+  flex: none;
+  width: 0.9rem;
+  height: 0.9rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+.ts-sg-main {
+  display: grid;
+  gap: 0.1rem;
+  min-width: 0;
+}
+.ts-sg-link {
+  text-decoration: none;
+}
+.ts-sg-link:hover {
+  text-decoration: underline;
+}
+.ts-sg-title {
+  min-width: 0;
+  font-weight: 600;
+  color: rgb(var(--fg-strong) / 1);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.ts-sg--recent {
+  min-width: 0;
+}
+.ts-sg--recent .ts-sg-title {
+  flex: 1 1 auto;
+  font-family: var(--font-mono);
+  font-size: 0.8125rem;
+  font-weight: 500;
+}
+.ts-sg-year {
+  font-weight: 400;
+  color: rgb(var(--fg-muted) / 1);
+}
+.ts-sg-meta {
+  font-family: var(--font-mono);
+  font-size: 0.625rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+.ts-sugg-note {
+  margin: 0.2rem 0.5rem 0.3rem;
+  font-size: 0.75rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+.ts-hints {
+  list-style: none;
+  margin: 0;
+  padding: 0 0.25rem;
+  display: grid;
+  gap: 0.15rem;
+}
+.ts-hints li {
+  display: flex;
+  align-items: center;
+  gap: 0.6rem;
+  min-height: 1.9rem;
+  padding: 0 0.25rem;
+  font-size: 0.75rem;
+  color: rgb(var(--fg-default) / 1);
+}
+.ts-hint-tok {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  height: 1.5rem;
+  padding: 0 0.55rem;
+  border-radius: var(--radius-pill);
+  border: 1px solid rgb(var(--accent-warm) / 0.35);
+  background: rgb(var(--accent-warm) / 0.12);
+  font-size: 0.75rem;
+  font-weight: 600;
+  white-space: nowrap;
+}
+.ts-hint-tok b {
+  font-family: var(--font-mono);
+  font-size: 0.625rem;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  color: rgb(var(--accent-warm-text) / 1);
+}
+@media (max-width: 40rem) {
+  .ts-kbd {
+    display: none;
+  }
+  /* Une puce et un mot doivent tenir sur la ligne du champ, avec la croix au bout. */
+  .ts-input {
+    flex-basis: 5rem;
+    min-width: 5rem;
+  }
+  .ts-hints {
+    display: none;
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  .ts-chip,
+  .ts-sugg {
+    animation: none;
+  }
+  .ts-ico--spin {
+    animation-duration: 2s;
+  }
+}
+</style>
diff --git a/apps/web/app/components/search/WorkCards.vue b/apps/web/app/components/search/WorkCards.vue
new file mode 100644
index 00000000..70518f36
--- /dev/null
+++ b/apps/web/app/components/search/WorkCards.vue
@@ -0,0 +1,996 @@
+<script setup lang="ts">
+/**
+ * La vue Œuvres : une carte par œuvre, ses releases dépliées dedans.
+ *
+ * La carte ENTIÈRE ouvre : un clic sur l'en-tête, ou le chevron au bout de la
+ * ligne, déplie l'œuvre sur la découpe du premier torrent du tri. Les pastilles
+ * de découpe (épisode, saison, intégrale) ne sont plus la seule porte : elles
+ * choisissent ce qu'on regarde, ouverte ou fermée.
+ *
+ * Dedans, la structure se lit avant les fichiers, comme sur la page d'un
+ * groupe : saisons, puis épisodes avec leur compte, leurs résolutions et leurs
+ * seeders, et les releases sous l'épisode qu'on déplie. La saison la plus
+ * récente et son premier épisode sont ouverts d'office ; le reste attend un
+ * clic. Les lignes sont celles de la vue Releases, en variante compacte.
+ */
+import { formatAge, formatDate, formatSize } from '~/utils/format';
+import { kindOfSlug } from '~/utils/searchTokens';
+import { scopeLabelKey, type GroupScope, type ScopeSummary } from '~/utils/groupScopes';
+import { homeScope as homeScopeOf, scopesOf as scopesOfList, unitsOf as splitUnits, type Unit as StructUnit } from '~/utils/workUnits';
+import type { CatalogueRow } from './ReleaseRows.vue';
+
+export interface WorkGroup {
+  key: string;
+  source: 'tmdb' | 'igdb' | 'openlibrary' | 'solo';
+  externalId: string;
+  releaseCount: number;
+  latest: string;
+  leadName: string;
+  categoryIds?: string[];
+  minSize?: number;
+  maxSize?: number;
+  seedTotal?: number;
+  seedMax?: number;
+  leechTotal?: number;
+  partnerCount?: number;
+  peerCount?: number;
+  scopes?: ScopeSummary[];
+  defaultScope?: GroupScope;
+  firstScope?: GroupScope;
+  work?: { title: string; year: number | null; posterUrl: string | null; type: string | null; tint?: string | null } | null;
+  tagSlugs?: string[];
+}
+
+const props = withDefaults(
+  defineProps<{
+    groups: WorkGroup[];
+    categoryLabel: (ids: string[]) => string | null;
+    dense?: boolean;
+    /** Les filtres de la page, pour que les releases dépliées y obéissent aussi. */
+    filterQuery?: Record<string, string | number | undefined>;
+    /** Le tri de la page : les releases dépliées le suivent. */
+    sortBy?: string;
+    order?: 'asc' | 'desc';
+  }>(),
+  { dense: false, filterQuery: () => ({}), sortBy: 'age', order: 'desc' },
+);
+
+const { t } = useI18n();
+
+const titleOf = (g: WorkGroup) => g.work?.title || g.leadName;
+const pageHref = (g: WorkGroup) => `/torrents/group/${g.key}`;
+const largePoster = (g: WorkGroup) => g.work?.posterUrl?.replace('/w342/', '/w500/') ?? null;
+
+function kindIcon(g: WorkGroup): string {
+  if (g.source === 'igdb') return 'ph:game-controller-bold';
+  if (g.source === 'openlibrary') return 'ph:book-open-bold';
+  if (g.externalId.startsWith('tv/')) return 'ph:television-bold';
+  if (g.externalId.startsWith('movie/')) return 'ph:film-slate-bold';
+  return 'ph:package-bold';
+}
+
+/* ── Sans affiche : un monogramme, pas une tuile grise ─────────────────────── */
+const initialOf = (g: WorkGroup) => {
+  const m = titleOf(g).match(/\p{L}|\p{N}/u);
+  return (m?.[0] ?? '·').toUpperCase();
+};
+function monoHue(g: WorkGroup): number {
+  const seed = props.categoryLabel(g.categoryIds ?? []) ?? g.source;
+  let h = 0;
+  for (const ch of seed) h = (h * 31 + ch.charCodeAt(0)) % 360;
+  return h;
+}
+function cardStyle(g: WorkGroup, index: number): Record<string, string> {
+  const style: Record<string, string> = { '--i': String(Math.min(index % 20, 12)) };
+  if (g.work?.tint) style['--work-tint'] = g.work.tint;
+  return style;
+}
+
+/* ── L'échelle des qualités : ce qui existe, résolutions puis sources ─────── */
+const resolutionRank = (slug: string) => {
+  const m = slug.match(/(\d{3,4})[pi]/);
+  if (m) return Number(m[1]);
+  if (slug === '8k') return 4320;
+  if (slug === '4k' || slug === 'uhd') return 2160;
+  return 0;
+};
+function ladder(g: WorkGroup): { resolutions: string[]; sources: string[] } {
+  const res: string[] = [];
+  const src: string[] = [];
+  for (const slug of g.tagSlugs ?? []) {
+    const kind = kindOfSlug(slug);
+    if (kind === 'resolution') res.push(slug);
+    else if (kind === 'source') src.push(slug);
+  }
+  return {
+    resolutions: Array.from(new Set(res)).sort((a, b) => resolutionRank(b) - resolutionRank(a)).slice(0, 4),
+    sources: Array.from(new Set(src)).slice(0, 4),
+  };
+}
+
+type SwarmState = 'dead' | 'thin' | 'ok' | 'hot';
+function swarmState(g: WorkGroup): SwarmState {
+  const s = g.seedTotal ?? g.seedMax ?? 0;
+  if (s === 0) return 'dead';
+  if (s < 3) return 'thin';
+  if (s >= 20) return 'hot';
+  return 'ok';
+}
+function sizeRange(g: WorkGroup): string {
+  if (!g.minSize && !g.maxSize) return '';
+  const a = formatSize(g.minSize ?? 0);
+  const b = formatSize(g.maxSize ?? 0);
+  return a === b ? a : `${a} – ${b}`;
+}
+function meta(g: WorkGroup): string {
+  const parts: string[] = [];
+  const cat = props.categoryLabel(g.categoryIds ?? []);
+  if (cat) parts.push(cat);
+  parts.push(t('search.works.releases', g.releaseCount));
+  if (g.partnerCount) parts.push(t('search.works.partners', { n: g.partnerCount }));
+  return parts.join(' · ');
+}
+
+/* ── Les découpes ─────────────────────────────────────────────────────────── */
+const scopesOf = (g: WorkGroup): ScopeSummary[] => scopesOfList(g.scopes);
+function scopeLabel(s: ScopeSummary): string {
+  return s.scope === 'all' ? t('search.group.scope.all', s.units) : t(scopeLabelKey(s.scope), { n: s.units });
+}
+const homeScope = (g: WorkGroup): GroupScope => homeScopeOf(g);
+const chosen = ref(new Map<string, GroupScope>());
+const scopeOf = (g: WorkGroup) => chosen.value.get(g.key) ?? homeScope(g);
+
+/* ── Le dépliage : une requête par carte et par découpe ───────────────────── */
+interface Unit {
+  key: string;
+  kind: StructUnit<CatalogueRow>['kind'];
+  season: number | null;
+  episode: number | null;
+  label: string | null;
+  order: number;
+  rows: CatalogueRow[];
+  seeders: number;
+  resolutions: string[];
+}
+/** Un bloc de saison (en découpe « épisode ») : ses épisodes, son total. */
+interface SeasonBlock {
+  key: string;
+  season: number | null;
+  label: string | null;
+  units: Unit[];
+  seeders: number;
+}
+type Body =
+  | { state: 'loading' }
+  | { state: 'error' }
+  | { state: 'ready'; blocks: SeasonBlock[]; total: number };
+const open = ref(new Set<string>());
+const bodies = ref(new Map<string, Body>());
+const openUnits = ref(new Map<string, Set<string>>());
+const openSeasons = ref(new Map<string, Set<string>>());
+const pad = (n: number) => String(n).padStart(2, '0');
+const bodyKey = (g: WorkGroup, scope: GroupScope) => `${g.key}|${scope}`;
+
+function unitLabel(u: StructUnit<CatalogueRow>): string | null {
+  if (u.kind === 'episode') return t('search.works.unit.episodeShort', { e: pad(u.episode ?? 0) });
+  if (u.kind === 'season') return t('search.works.unit.season', { s: pad(u.season ?? 0) });
+  if (u.kind === 'integral') return t('search.works.unit.integral');
+  return null;
+}
+function decorate(u: StructUnit<CatalogueRow>): Unit {
+  const res = new Set<string>();
+  let seeders = 0;
+  for (const r of u.rows) {
+    seeders += r.stats?.seeders ?? 0;
+    for (const tg of r.tags ?? []) if (kindOfSlug(tg.slug) === 'resolution') res.add(tg.slug);
+  }
+  return {
+    key: u.key,
+    kind: u.kind,
+    season: u.season,
+    episode: u.episode,
+    label: unitLabel(u),
+    order: u.order,
+    rows: u.rows,
+    seeders,
+    resolutions: Array.from(res).sort((a, b) => resolutionRank(b) - resolutionRank(a)),
+  };
+}
+/**
+ * Les blocs : en découpe « épisode », une saison par bloc avec ses épisodes ;
+ * sinon un bloc unique sans en-tête. Le premier bloc et sa première unité
+ * s'ouvrent d'office.
+ */
+function blocksOf(rows: CatalogueRow[], scope: GroupScope): SeasonBlock[] {
+  const units = splitUnits(rows, scope).map(decorate);
+  if (scope !== 'episode') {
+    return [{ key: 'all', season: null, label: null, units, seeders: units.reduce((a, u) => a + u.seeders, 0) }];
+  }
+  const map = new Map<string, SeasonBlock>();
+  for (const u of units) {
+    const k = `s${u.season ?? 'x'}`;
+    const b = map.get(k) ?? {
+      key: k,
+      season: u.season,
+      label: u.season === null ? t('search.group.seasonUnknown') : t('search.works.unit.season', { s: pad(u.season) }),
+      units: [],
+      seeders: 0,
+    };
+    b.units.push(u);
+    b.seeders += u.seeders;
+    map.set(k, b);
+  }
+  return Array.from(map.values()).sort((a, b) => (b.season ?? -1) - (a.season ?? -1));
+}
+
+async function load(g: WorkGroup, scope: GroupScope) {
+  const k = bodyKey(g, scope);
+  // La carte des corps est remplacée quand les filtres changent : une réponse
+  // partie avant ce remplacement appartient à l'ancienne carte, et n'écrit pas.
+  const map = bodies.value;
+  map.set(k, { state: 'loading' });
+  try {
+    const res = await $fetch<{ data: CatalogueRow[]; pagination: { total: number } }>('/api/torrents', {
+      query: { ...props.filterQuery, groupKey: g.key, groupScope: scope, limit: 60, sortBy: props.sortBy, order: props.order, page: 1 },
+    });
+    if (bodies.value !== map) return;
+    const blocks = blocksOf(res.data, scope);
+    bodies.value.set(k, { state: 'ready', blocks, total: res.pagination.total });
+    // Ouverts d'office : le premier bloc, et sa première unité.
+    openSeasons.value.set(k, new Set(blocks[0] ? [blocks[0].key] : []));
+    openUnits.value.set(k, new Set(blocks[0]?.units[0] ? [blocks[0].units[0].key] : []));
+  } catch {
+    if (bodies.value === map) map.set(k, { state: 'error' });
+  }
+}
+
+const isOpen = (g: WorkGroup) => open.value.has(g.key);
+const bodyOf = (g: WorkGroup) => bodies.value.get(bodyKey(g, scopeOf(g)));
+const bodyId = (g: WorkGroup) => `work-body-${g.key.replace(/[^a-zA-Z0-9_-]/g, '_')}`;
+
+function openOn(g: WorkGroup, scope: GroupScope) {
+  chosen.value.set(g.key, scope);
+  const next = new Set(open.value);
+  next.add(g.key);
+  open.value = next;
+  // Pas encore chargé, ou en erreur : on (re)demande.
+  const current = bodies.value.get(bodyKey(g, scope));
+  if (!current || current.state === 'error') void load(g, scope);
+}
+function fold(g: WorkGroup) {
+  const next = new Set(open.value);
+  next.delete(g.key);
+  open.value = next;
+}
+/** L'en-tête entier : un clic ouvre (sur la découpe maison) ou replie. Les liens et boutons gardent le leur. */
+function onHeaderClick(e: MouseEvent, g: WorkGroup) {
+  if ((e.target as HTMLElement | null)?.closest('a, button')) return;
+  // Copier un titre à la souris finit par un clic : ce n'est pas une demande d'ouvrir.
+  if (window.getSelection()?.toString()) return;
+  if (isOpen(g)) fold(g);
+  else openOn(g, scopeOf(g));
+}
+function toggle(g: WorkGroup) {
+  if (isOpen(g)) fold(g);
+  else openOn(g, scopeOf(g));
+}
+/** Une pastille : ouvre sur cette découpe ; celle déjà ouverte replie. */
+function pickScope(g: WorkGroup, scope: GroupScope) {
+  if (isOpen(g) && scopeOf(g) === scope) {
+    fold(g);
+    return;
+  }
+  openOn(g, scope);
+}
+const unitOpen = (g: WorkGroup, u: Unit) => openUnits.value.get(bodyKey(g, scopeOf(g)))?.has(u.key) ?? false;
+function toggleUnit(g: WorkGroup, u: Unit) {
+  const k = bodyKey(g, scopeOf(g));
+  const set = new Set(openUnits.value.get(k) ?? []);
+  if (set.has(u.key)) set.delete(u.key);
+  else set.add(u.key);
+  openUnits.value.set(k, set);
+}
+const seasonOpen = (g: WorkGroup, b: SeasonBlock) => openSeasons.value.get(bodyKey(g, scopeOf(g)))?.has(b.key) ?? false;
+function toggleSeason(g: WorkGroup, b: SeasonBlock) {
+  const k = bodyKey(g, scopeOf(g));
+  const set = new Set(openSeasons.value.get(k) ?? []);
+  if (set.has(b.key)) set.delete(b.key);
+  else set.add(b.key);
+  openSeasons.value.set(k, set);
+}
+
+// Les filtres ou le tri changent : ce qui était déplié se recharge.
+watch(
+  () => JSON.stringify([props.filterQuery, props.sortBy, props.order]),
+  () => {
+    bodies.value = new Map();
+    for (const g of props.groups) if (open.value.has(g.key)) void load(g, scopeOf(g));
+  },
+);
+</script>
+
+<template>
+  <ul class="works" :class="{ 'works--dense': dense }">
+    <li
+      v-for="(g, i) in groups"
+      :key="g.key"
+      class="work"
+      :class="{ 'work--open': isOpen(g), 'work--tinted': !!g.work?.tint }"
+      :data-state="swarmState(g)"
+      :style="cardStyle(g, i)"
+    >
+      <!-- L'en-tête est la porte : tout clic hors lien et bouton ouvre ou replie. -->
+      <div class="w-row" @click="onHeaderClick($event, g)">
+        <TorrentPosterHover
+          v-if="g.work?.posterUrl"
+          class="w-poster"
+          :src="g.work.posterUrl"
+          :large="largePoster(g)"
+          :alt="titleOf(g)"
+          :fallback-icon="kindIcon(g)"
+        />
+        <NuxtLink
+          v-else
+          class="w-poster w-mono"
+          :to="pageHref(g)"
+          :style="{ '--mono-hue': monoHue(g) }"
+          :aria-label="titleOf(g)"
+        >
+          <span class="w-mono-letter" aria-hidden="true">{{ initialOf(g) }}</span>
+          <Icon :name="kindIcon(g)" class="w-mono-kind" aria-hidden="true" />
+        </NuxtLink>
+
+        <div class="w-main">
+          <div class="w-l1">
+            <NuxtLink class="w-title" :class="{ 'w-title--plain': !g.work?.title }" :to="pageHref(g)">
+              {{ titleOf(g) }}
+            </NuxtLink>
+            <span v-if="g.work?.year" class="w-year">{{ g.work.year }}</span>
+          </div>
+          <div class="w-l2">
+            <span class="w-meta">{{ meta(g) }}</span>
+            <span v-if="ladder(g).resolutions.length || ladder(g).sources.length" class="w-ladder">
+              <span v-for="r in ladder(g).resolutions" :key="`r-${r}`" class="lad lad--res">{{ r }}</span>
+              <span v-for="s in ladder(g).sources" :key="`s-${s}`" class="lad">{{ s }}</span>
+            </span>
+            <!-- Les découpes : un choix, pas la seule porte. Une seule découpe : rien à choisir. -->
+            <span v-if="scopesOf(g).length > 1" class="w-scopes" role="group" :aria-label="t('search.works.scopeRow')">
+              <button
+                v-for="s in scopesOf(g)"
+                :key="s.scope"
+                type="button"
+                class="w-scope"
+                :class="{ 'w-scope--on': isOpen(g) && scopeOf(g) === s.scope }"
+                :aria-pressed="isOpen(g) && scopeOf(g) === s.scope"
+                @click="pickScope(g, s.scope)"
+              >
+                {{ scopeLabel(s) }}
+              </button>
+            </span>
+          </div>
+        </div>
+
+        <!-- Les chiffres, comme sur la page d'un groupe : seeders, puis taille et âge empilés. -->
+        <div class="w-figures">
+          <span class="w-fig w-fig--seed">
+            <span class="sr-only">{{ t('search.rows.swarm.label') }}</span>
+            <span class="w-pip" aria-hidden="true" />{{ g.seedTotal ?? 0 }}
+          </span>
+          <span class="w-fig-stack">
+            <span v-if="sizeRange(g)" class="w-fig w-fig--size">
+              <span class="sr-only">{{ t('search.rows.size') }}</span>{{ sizeRange(g) }}
+            </span>
+            <time class="w-fig w-fig--age" :datetime="g.latest" :title="formatDate(g.latest)">
+              <span class="sr-only">{{ t('search.rows.age') }}</span>{{ formatAge(g.latest) }}
+            </time>
+          </span>
+        </div>
+        <button
+          type="button"
+          class="w-toggle"
+          :aria-expanded="isOpen(g)"
+          :aria-controls="isOpen(g) ? bodyId(g) : undefined"
+          :aria-label="isOpen(g) ? t('search.works.close') : t('search.works.open')"
+          @click="toggle(g)"
+        >
+          <Icon name="ph:caret-down-bold" class="w-toggle-car" aria-hidden="true" />
+        </button>
+      </div>
+
+      <div v-if="isOpen(g)" :id="bodyId(g)" class="w-body">
+        <p v-if="!bodyOf(g) || bodyOf(g)!.state === 'loading'" class="w-note">
+          <Icon name="ph:circle-notch" class="animate-spin" aria-hidden="true" />
+          {{ t('search.works.loading') }}
+        </p>
+        <p v-else-if="bodyOf(g)!.state === 'error'" class="w-note w-note--err">{{ t('search.works.error') }}</p>
+        <template v-else-if="bodyOf(g)!.state === 'ready'">
+          <p v-if="(bodyOf(g) as { blocks: SeasonBlock[] }).blocks.length === 0" class="w-note">{{ t('search.works.empty') }}</p>
+          <div v-for="b in (bodyOf(g) as { blocks: SeasonBlock[] }).blocks" :key="b.key" class="w-season" :class="{ 'w-season--open': seasonOpen(g, b) }">
+            <!-- Une saison : en-tête repliable, comme sur la page du groupe. -->
+            <button v-if="b.label" type="button" class="w-season-h" :aria-expanded="seasonOpen(g, b)" @click="toggleSeason(g, b)">
+              <span class="w-season-name">{{ b.label }}</span>
+              <span class="w-season-n">{{ t('search.works.episodes', b.units.length) }}</span>
+              <span class="w-season-seed" :class="{ 'is-live': b.seeders > 0 }">
+                <Icon name="ph:arrow-up-bold" aria-hidden="true" />{{ b.seeders }}
+              </span>
+              <Icon name="ph:caret-down-bold" class="w-car" aria-hidden="true" />
+            </button>
+            <div v-show="!b.label || seasonOpen(g, b)" class="w-units">
+              <div v-for="u in b.units" :key="u.key" class="unit" :class="{ 'unit--open': unitOpen(g, u) }">
+                <!-- Un épisode, une saison, l'intégrale : ce qu'il contient avant de l'ouvrir. -->
+                <button v-if="u.label" type="button" class="unit-h" :aria-expanded="unitOpen(g, u)" @click="toggleUnit(g, u)">
+                  <span class="unit-name">{{ u.label }}</span>
+                  <span class="unit-n">{{ t('search.works.releases', u.rows.length) }}</span>
+                  <span class="unit-res">
+                    <span v-for="r in u.resolutions" :key="r" class="unit-r">{{ r }}</span>
+                  </span>
+                  <span class="unit-seed" :class="{ 'is-live': u.seeders > 0 }">
+                    <Icon name="ph:arrow-up-bold" aria-hidden="true" />{{ u.seeders }}
+                  </span>
+                  <Icon name="ph:caret-down-bold" class="w-car" aria-hidden="true" />
+                </button>
+                <div v-show="!u.label || unitOpen(g, u)" class="unit-rows">
+                  <SearchReleaseRows :torrents="u.rows" :dense="dense" :show-header="false" nested />
+                </div>
+              </div>
+            </div>
+          </div>
+          <div class="w-foot">
+            <button type="button" class="w-fold" @click="fold(g)">
+              <Icon name="ph:caret-up-bold" aria-hidden="true" />
+              {{ t('search.works.close') }}
+            </button>
+            <NuxtLink class="w-all" :to="pageHref(g)">
+              {{ t('search.works.openPage') }}
+              <Icon name="ph:arrow-right-bold" aria-hidden="true" />
+            </NuxtLink>
+          </div>
+        </template>
+      </div>
+    </li>
+  </ul>
+</template>
+
+<style scoped>
+/*
+ * L'échelle : 10 · 11 · 12 · 13 · 14 · 16 · 20 · 26 px, et rien entre deux.
+ * Le mono capitales est réservé aux repères (unités, saisons) ; la ligne méta
+ * est en texte courant, bas de casse.
+ */
+.works {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: grid;
+  gap: 0.5rem;
+}
+.work {
+  position: relative;
+  overflow: hidden;
+  border: 1px solid rgb(var(--line-default) / 1);
+  border-radius: var(--radius-lg);
+  background: rgb(var(--bg-surface) / 1);
+  transition:
+    border-color var(--dur-2) var(--ease-standard),
+    box-shadow var(--dur-2) var(--ease-standard);
+  animation: work-in var(--dur-4) var(--ease-emphasis) both;
+  animation-delay: calc(var(--i, 0) * 30ms);
+}
+@keyframes work-in {
+  from {
+    opacity: 0;
+    transform: translateY(0.4rem);
+  }
+}
+.work:hover {
+  border-color: rgb(var(--line-strong) / 1);
+  box-shadow: 0 14px 28px -20px rgb(var(--shadow-color) / var(--shadow-strength));
+}
+.work--open {
+  border-color: rgb(var(--line-strong) / 1);
+}
+.work::before {
+  content: '';
+  position: absolute;
+  inset: 0 auto 0 0;
+  width: 3px;
+  background: rgb(var(--fg-faint) / 0.6);
+}
+.work[data-state='hot']::before,
+.work[data-state='ok']::before {
+  background: linear-gradient(rgb(var(--online) / 0.9), rgb(var(--online) / 0.25));
+}
+.work[data-state='thin']::before {
+  background: linear-gradient(rgb(var(--warning) / 0.9), rgb(var(--warning) / 0.25));
+}
+.work[data-state='dead']::before {
+  background: rgb(var(--danger) / 0.5);
+}
+.work.work--tinted::before {
+  background: linear-gradient(rgb(var(--work-tint) / 0.85), rgb(var(--work-tint) / 0.25));
+}
+.work.work--tinted {
+  background:
+    linear-gradient(90deg, rgb(var(--work-tint) / 0.09), rgb(var(--work-tint) / 0) 42%),
+    rgb(var(--bg-surface) / 1);
+}
+
+/* ── L'en-tête : une porte, un chevron ───────────────────────────────────── */
+.w-row {
+  display: grid;
+  grid-template-columns: 56px minmax(0, 1fr) auto 2.25rem;
+  gap: 0.9rem;
+  align-items: center;
+  padding: 0.65rem 0.6rem 0.65rem 1rem;
+  cursor: pointer;
+  user-select: none;
+}
+.works--dense .w-row {
+  grid-template-columns: 44px minmax(0, 1fr) auto 2.25rem;
+  padding: 0.45rem 0.6rem 0.45rem 0.8rem;
+}
+.w-poster {
+  width: 56px;
+  height: 84px;
+  border-radius: var(--radius-sm);
+  overflow: hidden;
+}
+.works--dense .w-poster {
+  width: 44px;
+  height: 66px;
+}
+.w-mono {
+  position: relative;
+  display: grid;
+  place-items: center;
+  border: 1px solid hsl(var(--mono-hue, 40) 40% 50% / 0.45);
+  background:
+    radial-gradient(hsl(var(--mono-hue, 40) 45% 60% / 0.28) 1px, transparent 1px) 0 0 / 7px 7px,
+    linear-gradient(160deg, hsl(var(--mono-hue, 40) 40% 50% / 0.22), hsl(var(--mono-hue, 40) 40% 50% / 0.06));
+  text-decoration: none;
+}
+.w-mono-letter {
+  font-family: var(--font-display);
+  font-style: italic;
+  font-weight: 500;
+  font-size: 1.625rem;
+  line-height: 1;
+  color: rgb(var(--fg-strong) / 0.85);
+}
+.works--dense .w-mono-letter {
+  font-size: 1.25rem;
+}
+.w-mono-kind {
+  position: absolute;
+  right: 0.25rem;
+  bottom: 0.25rem;
+  width: 0.75rem;
+  height: 0.75rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+.w-main {
+  min-width: 0;
+  display: grid;
+  gap: 0.3rem;
+  user-select: text;
+}
+.w-l1 {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 0.6rem;
+}
+.w-title {
+  font-family: var(--font-display);
+  font-style: italic;
+  font-weight: 500;
+  font-size: 1.25rem;
+  line-height: 1.15;
+  color: rgb(var(--fg-strong) / 1);
+  text-decoration: none;
+  border-radius: var(--radius-xs);
+}
+.works--dense .w-title {
+  font-size: 1rem;
+}
+.w-title:hover {
+  text-decoration: underline;
+  text-decoration-color: rgb(var(--accent-warm) / 1);
+  text-underline-offset: 0.2em;
+}
+.w-title--plain {
+  font-family: var(--font-sans);
+  font-style: normal;
+  font-weight: 600;
+  font-size: 1rem;
+  line-height: 1.3;
+  overflow-wrap: anywhere;
+}
+.w-year {
+  font-family: var(--font-display);
+  font-weight: 500;
+  font-size: 0.8125rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+.w-l2 {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.3rem 0.65rem;
+  min-width: 0;
+}
+.w-meta {
+  font-size: 0.75rem;
+  line-height: 1.4;
+  color: rgb(var(--fg-muted) / 1);
+}
+.w-ladder {
+  display: inline-flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.25rem;
+}
+.lad {
+  display: inline-flex;
+  align-items: center;
+  height: 1.25rem;
+  padding: 0 0.4rem;
+  border: 1px solid rgb(var(--line-default) / 1);
+  border-radius: var(--radius-xs);
+  background: rgb(var(--bg-inset) / 1);
+  font-size: 0.6875rem;
+  font-weight: 500;
+  color: rgb(var(--fg-muted) / 1);
+  text-transform: uppercase;
+}
+.lad--res {
+  font-weight: 700;
+  color: rgb(var(--fg-default) / 1);
+}
+.w-scopes {
+  display: inline-flex;
+  flex-wrap: wrap;
+  gap: 0.25rem;
+}
+.w-scope {
+  display: inline-flex;
+  align-items: center;
+  min-height: 1.5rem;
+  padding: 0 0.5rem;
+  border: 1px solid rgb(var(--line-default) / 1);
+  border-radius: var(--radius-xs);
+  background: transparent;
+  font-size: 0.75rem;
+  font-weight: 600;
+  color: rgb(var(--fg-muted) / 1);
+  white-space: nowrap;
+  transition:
+    color var(--dur-1) var(--ease-standard),
+    border-color var(--dur-1) var(--ease-standard),
+    background-color var(--dur-1) var(--ease-standard);
+}
+.w-scope:hover {
+  color: rgb(var(--fg-strong) / 1);
+  border-color: rgb(var(--fg-muted) / 1);
+}
+.w-scope--on {
+  background: rgb(var(--accent-warm) / 1);
+  border-color: rgb(var(--accent-warm) / 1);
+  color: rgb(var(--accent-warm-fg) / 1);
+}
+.w-scope--on:hover {
+  color: rgb(var(--accent-warm-fg) / 1);
+  border-color: rgb(var(--accent-warm) / 1);
+}
+
+/* Les chiffres : les seeders, puis taille et âge empilés, à leur largeur — rien de coupé. */
+.w-figures {
+  display: flex;
+  align-items: center;
+  gap: 1.1rem;
+  font-family: var(--font-mono);
+  font-variant-numeric: tabular-nums;
+  text-align: right;
+  white-space: nowrap;
+}
+.w-fig--seed {
+  display: inline-flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 0.4rem;
+  min-width: 3rem;
+  font-size: 0.8125rem;
+  font-weight: 700;
+  color: rgb(var(--fg-muted) / 1);
+}
+.work[data-state='hot'] .w-fig--seed,
+.work[data-state='ok'] .w-fig--seed {
+  color: rgb(var(--online) / 1);
+}
+.work[data-state='thin'] .w-fig--seed {
+  color: rgb(var(--warning) / 1);
+}
+.w-fig-stack {
+  display: grid;
+  gap: 0.15rem;
+  justify-items: end;
+}
+.w-fig--size {
+  font-size: 0.75rem;
+  color: rgb(var(--fg-default) / 1);
+}
+.w-fig--age {
+  font-size: 0.6875rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+.w-pip {
+  flex: none;
+  width: 0.5rem;
+  height: 0.5rem;
+  border-radius: 50%;
+  background: rgb(var(--fg-faint) / 1);
+}
+.work[data-state='hot'] .w-pip,
+.work[data-state='ok'] .w-pip {
+  background: rgb(var(--online) / 1);
+  box-shadow: 0 0 0 3px rgb(var(--online) / 0.18);
+}
+.work[data-state='thin'] .w-pip {
+  background: rgb(var(--warning) / 1);
+}
+.work[data-state='dead'] .w-pip {
+  background: transparent;
+  box-shadow: inset 0 0 0 1.5px rgb(var(--danger) / 0.7);
+}
+.w-toggle {
+  display: inline-grid;
+  place-items: center;
+  width: 2.25rem;
+  height: 2.25rem;
+  border-radius: var(--radius-sm);
+  color: rgb(var(--fg-muted) / 1);
+  transition: background-color var(--dur-1) var(--ease-standard), color var(--dur-1) var(--ease-standard);
+}
+.w-row:hover .w-toggle,
+.w-toggle:hover {
+  background: rgb(var(--bg-inset) / 1);
+  color: rgb(var(--fg-strong) / 1);
+}
+.w-toggle-car,
+.w-car {
+  width: 0.7rem;
+  height: 0.7rem;
+  transition: transform var(--dur-2) var(--ease-standard);
+}
+.work--open .w-toggle-car,
+.w-season--open .w-season-h .w-car,
+.unit--open .unit-h .w-car {
+  transform: rotate(180deg);
+}
+
+/* ── Dedans : saisons, épisodes, releases ────────────────────────────────── */
+.w-body {
+  display: grid;
+  gap: 0.5rem;
+  padding: 0.5rem 0.75rem 0.75rem;
+  border-top: 1px solid rgb(var(--line-default) / 1);
+  background: rgb(var(--bg-inset) / 0.6);
+  animation: w-body-in var(--dur-4) var(--ease-emphasis) both;
+}
+@keyframes w-body-in {
+  from {
+    opacity: 0;
+    transform: translateY(-0.35rem);
+    clip-path: inset(0 0 100% 0);
+  }
+  to {
+    opacity: 1;
+    transform: none;
+    clip-path: inset(0);
+  }
+}
+.w-note {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+  margin: 0.2rem 0;
+  font-size: 0.8125rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+.w-note--err {
+  color: rgb(var(--danger) / 1);
+}
+.w-season {
+  display: grid;
+  gap: 0.35rem;
+}
+.w-season-h,
+.unit-h {
+  display: flex;
+  align-items: center;
+  gap: 0.6rem;
+  width: 100%;
+  min-height: 2.25rem;
+  padding: 0 0.6rem;
+  border-radius: var(--radius-sm);
+  text-align: left;
+  transition: background-color var(--dur-1) var(--ease-standard);
+}
+.w-season-h:hover,
+.unit-h:hover {
+  background: rgb(var(--bg-hover) / 1);
+}
+.w-season-h {
+  border: 1px solid rgb(var(--line-default) / 1);
+  background: rgb(var(--bg-surface) / 1);
+}
+.w-season-name {
+  font-size: 0.875rem;
+  font-weight: 600;
+  color: rgb(var(--fg-strong) / 1);
+}
+.w-season-n,
+.unit-n {
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+.w-season-seed,
+.unit-seed {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.15rem;
+  margin-left: auto;
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  font-variant-numeric: tabular-nums;
+  color: rgb(var(--fg-faint) / 1);
+}
+.w-season-seed.is-live,
+.unit-seed.is-live {
+  color: rgb(var(--online) / 1);
+}
+.w-season-seed :deep(svg),
+.unit-seed :deep(svg) {
+  width: 0.6rem;
+  height: 0.6rem;
+}
+.w-units {
+  display: grid;
+  gap: 0.3rem;
+}
+.w-season--open .w-units {
+  padding-left: 0.5rem;
+  border-left: 2px solid rgb(var(--line-default) / 1);
+}
+.unit {
+  display: grid;
+  gap: 0.3rem;
+}
+.unit-h {
+  min-height: 2rem;
+}
+.unit-name {
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  color: rgb(var(--fg-strong) / 1);
+}
+.unit-res {
+  display: inline-flex;
+  gap: 0.25rem;
+}
+.unit-r {
+  padding: 0 0.3rem;
+  border: 1px solid rgb(var(--accent-warm) / 0.4);
+  border-radius: var(--radius-xs);
+  font-family: var(--font-mono);
+  font-size: 0.625rem;
+  color: rgb(var(--accent-warm-text) / 1);
+}
+.unit-rows {
+  padding-left: 0.5rem;
+}
+.w-foot {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+  padding-top: 0.25rem;
+}
+.w-fold,
+.w-all {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  font-size: 0.75rem;
+  font-weight: 600;
+  color: rgb(var(--fg-muted) / 1);
+  text-decoration: none;
+  border-radius: var(--radius-xs);
+}
+.w-fold:hover,
+.w-all:hover {
+  color: rgb(var(--fg-strong) / 1);
+}
+.w-fold :deep(svg),
+.w-all :deep(svg) {
+  width: 0.75rem;
+  height: 0.75rem;
+}
+
+/* ── Quand la place manque ───────────────────────────────────────────────── */
+@container (max-width: 52rem) {
+  .w-figures {
+    gap: 0.75rem;
+  }
+}
+@container (max-width: 40rem) {
+  .w-row {
+    grid-template-columns: 44px minmax(0, 1fr) 2.25rem;
+    align-items: start;
+  }
+  .w-poster {
+    width: 44px;
+    height: 66px;
+  }
+  .w-figures {
+    grid-column: 2;
+    justify-content: start;
+    gap: 0.75rem;
+    text-align: left;
+  }
+  .w-fig--seed {
+    flex: none;
+    min-width: 0;
+    justify-content: flex-start;
+  }
+  .w-fig-stack {
+    justify-items: start;
+  }
+  /* La carte se resserre : l'échelle des qualités se retrouve dans les unités dépliées. */
+  .w-ladder {
+    display: none;
+  }
+  .w-toggle {
+    grid-row: 1;
+    grid-column: 3;
+  }
+  .w-scopes {
+    flex-wrap: nowrap;
+    width: 100%;
+    padding-right: 1.5rem;
+    overflow-x: auto;
+    scrollbar-width: none;
+    /* La rangée défile : un fondu au bord dit qu'il y en a d'autres. */
+    mask-image: linear-gradient(90deg, rgb(0 0 0 / 1) calc(100% - 1.5rem), rgb(0 0 0 / 0));
+    -webkit-mask-image: linear-gradient(90deg, rgb(0 0 0 / 1) calc(100% - 1.5rem), rgb(0 0 0 / 0));
+  }
+  .w-scopes::-webkit-scrollbar {
+    display: none;
+  }
+  .w-scope {
+    min-height: 2.25rem;
+    flex: none;
+  }
+  .unit-res {
+    display: none;
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  .work,
+  .w-body {
+    animation: none;
+  }
+  .work,
+  .w-scope,
+  .w-toggle,
+  .w-toggle-car,
+  .w-car,
+  .w-season-h,
+  .unit-h {
+    transition: none;
+  }
+}
+</style>
diff --git a/apps/web/app/components/shop/FreeleechPool.vue b/apps/web/app/components/shop/FreeleechPool.vue
index 7a58f7bb..201e9064 100644
--- a/apps/web/app/components/shop/FreeleechPool.vue
+++ b/apps/web/app/components/shop/FreeleechPool.vue
@@ -631,7 +631,7 @@ onBeforeUnmount(() => {
   padding: 0;
   margin: 0;
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 180px), 1fr));
   gap: 0.3rem 0.8rem;
 }
 .pool-patron {
diff --git a/apps/web/app/components/torrent/TorrentModerationPanel.vue b/apps/web/app/components/torrent/TorrentModerationPanel.vue
index 6dfcd7b9..7721a822 100644
--- a/apps/web/app/components/torrent/TorrentModerationPanel.vue
+++ b/apps/web/app/components/torrent/TorrentModerationPanel.vue
@@ -600,8 +600,8 @@ function formatDate(iso: string): string {
   display: inline-flex;
   align-items: center;
   font-family: var(--font-mono);
-  font-size: 0.5625rem;
-  letter-spacing: calc(0.16em * var(--tracking-scale));
+  font-size: var(--label-sm, 0.5625rem);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
   text-transform: uppercase;
   color: rgb(var(--fg-subtle));
   font-weight: 600;
@@ -629,16 +629,16 @@ function formatDate(iso: string): string {
   align-items: center;
   gap: 0.5rem;
   font-family: var(--font-mono);
-  font-size: 0.5625rem;
-  letter-spacing: calc(0.22em * var(--tracking-scale));
+  font-size: var(--label-sm, 0.5625rem);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
   text-transform: uppercase;
   color: rgb(var(--fg-subtle));
   margin: 0 0 0.2rem;
   font-weight: 600;
 }
 .mod-banner-count {
-  font-size: 0.5625rem;
-  letter-spacing: calc(0.18em * var(--tracking-scale));
+  font-size: var(--label-sm, 0.5625rem);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
   color: var(--c-text);
   background: rgb(var(--c) / 0.14);
   border: 1px solid var(--c-line);
@@ -689,8 +689,8 @@ function formatDate(iso: string): string {
 .mod-empty-glyph { font-size: 2rem; color: var(--c-text); opacity: 0.6; margin-bottom: 0.5rem; }
 .mod-empty-text {
   font-family: var(--font-mono);
-  font-size: 0.625rem;
-  letter-spacing: calc(0.22em * var(--tracking-scale));
+  font-size: var(--label-md, 0.625rem);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
   text-transform: uppercase;
   font-weight: 700;
   color: rgb(var(--fg-strong));
@@ -788,8 +788,8 @@ function formatDate(iso: string): string {
 }
 .mod-row-pip {
   font-family: var(--font-mono);
-  font-size: 0.5625rem;
-  letter-spacing: calc(0.16em * var(--tracking-scale));
+  font-size: var(--label-sm, 0.5625rem);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
   text-transform: uppercase;
   font-weight: 700;
   padding: 0.1rem 0.4rem;
@@ -808,7 +808,7 @@ function formatDate(iso: string): string {
 }
 .mod-row-time {
   font-family: var(--font-mono);
-  font-size: 0.625rem;
+  font-size: var(--label-md, 0.625rem);
   color: rgb(var(--fg-subtle));
 }
 .mod-row-statuschange {
@@ -821,8 +821,8 @@ function formatDate(iso: string): string {
   font-style: normal;
   font-weight: 700;
   text-transform: uppercase;
-  letter-spacing: calc(0.06em * var(--tracking-scale));
-  font-size: 0.625rem;
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  font-size: var(--label-md, 0.625rem);
   padding: 0.05rem 0.35rem;
   background: rgb(var(--r) / 0.14);
   border-radius: var(--radius-pill);
@@ -850,8 +850,8 @@ function formatDate(iso: string): string {
   align-items: center;
   gap: 0.5rem;
   font-family: var(--font-mono);
-  font-size: 0.625rem;
-  letter-spacing: calc(0.18em * var(--tracking-scale));
+  font-size: var(--label-md, 0.625rem);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
   text-transform: uppercase;
   color: rgb(var(--fg-muted));
   font-weight: 700;
@@ -912,7 +912,7 @@ function formatDate(iso: string): string {
   font-size: 0.75rem;
   font-weight: 700;
   text-transform: uppercase;
-  letter-spacing: calc(0.1em * var(--tracking-scale));
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
   cursor: pointer;
   transition:
     background var(--dur-2) ease,
diff --git a/apps/web/app/components/torrent/detail/AdminSwarmTable.vue b/apps/web/app/components/torrent/detail/AdminSwarmTable.vue
new file mode 100644
index 00000000..4f03b1be
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/AdminSwarmTable.vue
@@ -0,0 +1,405 @@
+<script setup lang="ts">
+import { formatAge, formatSize } from '~/utils/format';
+
+/**
+ * La liste des pairs, pour un administrateur.
+ *
+ * # Pourquoi une table
+ *
+ * C'est de la donnée d'exploitation : cinq colonnes homogènes qu'on parcourt
+ * verticalement pour repérer l'anomalie. Rien ne scanne mieux qu'une table —
+ * tant qu'il y a la largeur pour l'afficher.
+ *
+ * # Ce qui change en sortant de la page
+ *
+ * Sous 640 px, la table ne faisait que RÉTRÉCIR sa police à l'intérieur d'un
+ * cadre `overflow-x: auto`. À cinq colonnes, cela donnait un défilement
+ * horizontal dans une page qui défile déjà verticalement — le geste le plus
+ * facile à rater sur un téléphone, et le seul moyen d'atteindre « vu il y a ».
+ * Chaque ligne devient donc une carte : l'endpoint en tête, les quatre autres
+ * valeurs en paires libellé / valeur, plus rien à faire défiler de côté.
+ *
+ * Les libellés de colonne deviennent les libellés des paires — via
+ * `data-label`, pour que la table garde son `<thead>` sur grand écran et que le
+ * lecteur d'écran garde ses en-têtes de colonne dans les deux cas.
+ */
+export interface SwarmPeer {
+  id: string;
+  port: number;
+  isSeeder: boolean;
+  uploaded: number;
+  downloaded: number;
+  lastSeen: string;
+}
+
+const props = withDefaults(
+  defineProps<{
+    /** Les pairs actifs, tels que les projette `/api/torrents/:hash`. */
+    peers?: SwarmPeer[] | null;
+  }>(),
+  { peers: () => [] },
+);
+
+const rows = computed<SwarmPeer[]>(() => props.peers ?? []);
+
+/** Les douze premiers caractères suffisent à distinguer deux pairs à l'œil. */
+const ENDPOINT_CHARS = 12;
+</script>
+
+<template>
+  <section class="section">
+    <SectionHead
+      :title="$t('torrents.detail.sections.swarm')"
+      :count="rows.length"
+      icon="ph:users-three"
+    >
+      <template #action>
+        <span class="swarm-tag" :title="$t('torrents.detail.swarm.adminOnlyTooltip')">
+          {{ $t('torrents.detail.swarm.adminOnly') }}
+        </span>
+      </template>
+    </SectionHead>
+
+    <div class="swarm-frame">
+      <table class="swarm-table">
+        <!-- Nommé pour qui n'en voit pas l'en-tête de section : un lecteur
+             d'écran qui entre dans un tableau annonce sa légende, pas le
+             titre qui le précède dans le document. Masquée à l'œil, la
+             section est déjà titrée juste au-dessus. -->
+        <caption class="sr-only">{{ $t('torrents.detail.sections.swarm') }}</caption>
+        <thead>
+          <tr>
+            <th>{{ $t('torrents.detail.swarm.endpoint') }}</th>
+            <th>{{ $t('torrents.detail.swarm.type') }}</th>
+            <th>{{ $t('torrents.detail.swarm.uploaded') }}</th>
+            <th>{{ $t('torrents.detail.swarm.downloaded') }}</th>
+            <th class="swarm-col-last">{{ $t('torrents.detail.swarm.lastSeen') }}</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr v-if="rows.length === 0" class="swarm-row--empty">
+            <td colspan="5" class="swarm-empty">
+              <span class="swarm-empty-plate" aria-hidden="true">
+                <Icon name="ph:users-three" class="swarm-empty-icon" />
+              </span>
+              <span class="swarm-empty-text">{{ $t('torrents.detail.swarm.empty') }}</span>
+            </td>
+          </tr>
+          <tr v-for="peer in rows" :key="peer.id">
+            <td class="swarm-cell-endpoint" :data-label="$t('torrents.detail.swarm.endpoint')">
+              <span class="swarm-endpoint">{{ peer.id.slice(0, ENDPOINT_CHARS) }}…</span>
+              <span class="swarm-port">:{{ peer.port }}</span>
+            </td>
+            <td :data-label="$t('torrents.detail.swarm.type')">
+              <span
+                class="swarm-type"
+                :class="peer.isSeeder ? 'swarm-type--seeder' : 'swarm-type--leecher'"
+              >
+                <Icon
+                  :name="peer.isSeeder ? 'ph:arrow-up-bold' : 'ph:arrow-down-bold'"
+                  class="swarm-type__icon"
+                />
+                {{
+                  peer.isSeeder
+                    ? $t('torrents.detail.swarm.seeder')
+                    : $t('torrents.detail.swarm.leecher')
+                }}
+              </span>
+            </td>
+            <td class="swarm-num" :data-label="$t('torrents.detail.swarm.uploaded')">
+              {{ formatSize(peer.uploaded) }}
+            </td>
+            <td class="swarm-num" :data-label="$t('torrents.detail.swarm.downloaded')">
+              {{ formatSize(peer.downloaded) }}
+            </td>
+            <td
+              class="swarm-num swarm-col-last"
+              :data-label="$t('torrents.detail.swarm.lastSeen')"
+            >
+              {{ formatAge(peer.lastSeen) }}
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+  </section>
+</template>
+
+<style scoped>
+/* Copie locale : `.section` appartenait à la page, pas au CSS global. Les
+   quatre copies (ici, `BuffsForm`, `SupersedeForm`, `FederationSwarmToggle`)
+   restent identiques au caractère près — c'est déjà le piège que ce fichier
+   documente, et le rail ci-dessous est ajouté aux quatre à l'identique.
+
+   Le rail bleu est la marque de la famille « exploitation » : ce que l'ÉQUIPE
+   fait de la release, par opposition à ce qu'elle vaut (or) ou à ce qu'elle
+   contient (cyan). `--chart-1` était déclarée dans `main.css` et n'était
+   utilisée nulle part. Non textuelle : 4,27:1 en sombre, 3,31:1 en clair sur
+   ces surfaces, au-dessus des 3:1 de la 1.4.11. */
+.section {
+  --section-tone: var(--chart-1);
+  padding: 1rem 1.1rem;
+  border: 1px solid rgb(var(--line-default));
+  border-left: 3px solid rgb(var(--chart-1) / 0.55);
+  border-radius: var(--radius-lg);
+  background: rgb(var(--bg-surface));
+}
+
+/* La pastille « administrateurs seulement ». Elle vit dans le slot d'action de
+   `SectionHead`, donc dans CE fichier : le contenu d'un slot est compilé dans
+   la portée de l'appelant, pas dans celle du composant qui l'accueille. */
+.swarm-tag {
+  flex-shrink: 0;
+  padding: 0.18rem 0.45rem;
+  border: 1px solid rgb(var(--line-default));
+  border-radius: var(--radius-sm);
+  background: rgb(var(--bg-elevated) / 0.55);
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+  cursor: help;
+}
+
+.swarm-frame {
+  overflow-x: auto;
+  border: 1px solid rgb(var(--chart-1) / 0.22);
+  border-radius: var(--radius-lg);
+  background: rgb(var(--bg-elevated));
+  box-shadow: 0 6px 18px -10px
+    rgb(var(--shadow-color) / calc(0.55 * var(--shadow-strength)));
+}
+.swarm-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+}
+/* Voile de la teinte de famille à 16 % sous encre NEUTRE — le motif mesuré
+   (4,84:1 au pire pour `--fg-muted`, sur les huit teintes et les deux
+   thèmes). Le fond d'avant était un voile de `--bg-base` à 40 %, donc gris. */
+.swarm-table thead th {
+  padding: 0.65rem 1rem;
+  border-bottom: 1px solid rgb(var(--chart-1) / 0.3);
+  background:
+    linear-gradient(rgb(var(--chart-1) / 0.16), rgb(var(--chart-1) / 0.16)),
+    rgb(var(--bg-inset));
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+  text-align: left;
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+}
+.swarm-table tbody td {
+  padding: 0.6rem 1rem;
+  border-bottom: 1px solid rgb(var(--line-default) / 0.55);
+  color: rgb(var(--fg-default));
+  vertical-align: middle;
+}
+.swarm-table tbody tr:last-child td {
+  border-bottom: 0;
+}
+.swarm-table tbody tr:hover td {
+  background: rgb(var(--bg-elevated) / 0.45);
+}
+.swarm-col-last {
+  text-align: right;
+}
+
+.swarm-endpoint {
+  color: rgb(var(--fg-muted));
+}
+.swarm-port {
+  color: rgb(var(--fg-faint));
+}
+/* Des octets se comparent en colonne : sans chiffres de largeur fixe, deux
+   tailles voisines ne s'alignent pas et l'œil ne peut plus les ranger. */
+.swarm-num {
+  font-size: 0.65625rem;
+  font-variant-numeric: tabular-nums;
+  color: rgb(var(--fg-default));
+}
+
+.swarm-type {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.3rem;
+  padding: 0.18rem 0.5rem;
+  border: 1px solid;
+  border-radius: var(--radius-xs);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+  text-transform: uppercase;
+}
+/* `rem` et non le `text-[8px]` d'origine : `--ui-scale` n'est appliqué qu'une
+   fois, sur `html { font-size }`, donc une taille en pixels rendait le réglage
+   d'échelle de l'exploitant inerte sur cette flèche. */
+.swarm-type__icon {
+  font-size: 0.5rem;
+}
+/* Correctif de contraste, pas un choix esthétique.
+   Ces deux pastilles posaient `color: --online` sur `background: --online/0.08`
+   — une encre sur un voile d'ELLE-MÊME. Mesuré : **4,08:1 en thème clair** pour
+   le seeder et **4,07:1** pour le leecher, sous les 4,5:1 requis d'un texte, et
+   invisible en thème sombre où les mêmes paires donnent 6,04:1 et 6,98:1. C'est
+   très exactement le défaut que la note de `--danger-fg` décrit dans
+   `main.css` : la paire qui ne tient que dans un thème sur deux.
+   Fond NEUTRE, encre pleine : `--online` sur `--bg-inset` donne 8,41:1 en
+   sombre et 4,60:1 en clair, `--warning` 10,00:1 et 4,61:1. La flèche du
+   gabarit porte déjà l'information sans couleur. */
+.swarm-type--seeder {
+  border-color: rgb(var(--online) / 0.45);
+  background: rgb(var(--bg-inset));
+  color: rgb(var(--online));
+}
+.swarm-type--leecher {
+  border-color: rgb(var(--warning) / 0.45);
+  background: rgb(var(--bg-inset));
+  color: rgb(var(--warning));
+}
+
+/* L'absence de peers. Elle s'écrivait en capitales mono espacées de 0,22 em,
+   à 10 px, en gris : la typographie d'une ligne de journal système, pour un
+   état parfaitement normal. Elle se lit maintenant comme une phrase, sur la
+   trame de fond du site et un voile de la teinte de famille — et « rien ici »
+   cesse de ressembler à « quelque chose a cassé ». */
+.swarm-empty {
+  padding: 2.25rem 1rem;
+  background:
+    var(--bg-pattern-image),
+    linear-gradient(rgb(var(--chart-1) / 0.05), rgb(var(--chart-1) / 0.05)),
+    transparent;
+  background-size: var(--bg-pattern-step) var(--bg-pattern-step), auto, auto;
+  text-align: center;
+}
+.swarm-empty-plate {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 2.25rem;
+  height: 2.25rem;
+  margin-bottom: 0.55rem;
+  /* Plaque NEUTRE sous un glyphe teinté : `--chart-1` sur un voile d'elle-même
+     tombe à 2,90:1 en clair, sous les 3:1. */
+  background: rgb(var(--bg-inset));
+  border: 1px solid rgb(var(--chart-1) / 0.4);
+  border-radius: var(--radius-pill);
+}
+.swarm-empty-icon {
+  font-size: 1.1rem;
+  color: rgb(var(--chart-1));
+}
+.swarm-empty-text {
+  display: block;
+  margin: 0 auto;
+  max-width: 32ch;
+  font-family: var(--font-sans);
+  font-size: 0.8125rem;
+  font-weight: 500;
+  letter-spacing: normal;
+  line-height: 1.55;
+  text-transform: none;
+  color: rgb(var(--fg-muted));
+}
+
+/* ── Sous 640 px : des cartes, pas un défilement latéral ─────────────────── */
+@media (max-width: 40rem) {
+  .swarm-frame {
+    /* Plus rien à faire défiler de côté : chaque ligne tient dans la largeur. */
+    overflow-x: visible;
+    border: 0;
+    border-radius: 0;
+    background: transparent;
+    box-shadow: none;
+  }
+  .swarm-table,
+  .swarm-table tbody,
+  .swarm-table tbody tr,
+  .swarm-table tbody td {
+    display: block;
+    width: 100%;
+  }
+  /* Le `<thead>` sort de l'affichage sans sortir de l'arbre d'accessibilité :
+     `clip` plutôt que `display: none`, pour que la table reste une table. */
+  .swarm-table thead {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+  }
+  .swarm-table tbody tr {
+    margin-bottom: 0.6rem;
+    border: 1px solid rgb(var(--line-strong));
+    border-radius: var(--radius-md);
+    background: rgb(var(--bg-elevated));
+    box-shadow: 0 4px 12px -8px
+      rgb(var(--shadow-color) / calc(0.55 * var(--shadow-strength)));
+  }
+  .swarm-table tbody tr:last-child {
+    margin-bottom: 0;
+  }
+  .swarm-table tbody tr:hover td {
+    background: transparent;
+  }
+  .swarm-table tbody td {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 1rem;
+    padding: 0.45rem 0.75rem;
+    border-bottom: 1px solid rgb(var(--line-default) / 0.55);
+    text-align: right;
+  }
+  /* Le libellé de colonne redevient le libellé de la paire. */
+  .swarm-table tbody td::before {
+    content: attr(data-label);
+    flex: none;
+    font-size: var(--label-sm, 0.5625rem);
+    font-weight: var(--label-weight, 700);
+    letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+    text-align: left;
+    text-transform: uppercase;
+    color: rgb(var(--fg-muted));
+  }
+  /* L'endpoint est le titre de la carte : il prend la ligne entière, sans
+     libellé — « endpoint » devant une adresse n'apprend rien. */
+  .swarm-table tbody td.swarm-cell-endpoint {
+    display: block;
+    padding: 0.6rem 0.75rem 0.5rem;
+    border-bottom: 1px solid rgb(var(--line-default));
+    background: rgb(var(--bg-base) / 0.35);
+    font-size: 0.75rem;
+    text-align: left;
+  }
+  .swarm-table tbody td.swarm-cell-endpoint::before {
+    content: none;
+  }
+  .swarm-table tbody tr td:last-child {
+    border-bottom: 0;
+  }
+  .swarm-col-last {
+    text-align: right;
+  }
+  /* La ligne vide n'est pas une carte : c'est l'absence de cartes. */
+  .swarm-table tbody tr.swarm-row--empty {
+    border: 1px dashed rgb(var(--line-default));
+    background: transparent;
+    box-shadow: none;
+  }
+  .swarm-table tbody tr.swarm-row--empty td {
+    display: block;
+    border-bottom: 0;
+    text-align: center;
+  }
+  .swarm-table tbody tr.swarm-row--empty td::before {
+    content: none;
+  }
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/AdultGate.vue b/apps/web/app/components/torrent/detail/AdultGate.vue
new file mode 100644
index 00000000..9e4ba3f6
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/AdultGate.vue
@@ -0,0 +1,406 @@
+<script setup lang="ts">
+/**
+ * La page parallèle d'un membre qui a coupé le contenu adulte.
+ *
+ * # Pourquoi une page et non un bandeau
+ *
+ * Quand `/api/torrents/:hash` renvoie la forme caviardée, il n'y a RIEN à
+ * afficher : ni le nom, ni la taille, ni le swarm. Un bandeau au-dessus d'une
+ * page vide laisserait croire à une panne. Ici la page assume le filtre — elle
+ * mime la position du titre par trois barres de censure, montre la route qu'on
+ * a demandée avec le milieu du hash noirci, et pointe le réglage à un clic.
+ *
+ * Garder les quatre premiers et les quatre derniers caractères du hash suffit à
+ * dire « oui, il y a bien un document là » sans permettre de le recopier
+ * ailleurs.
+ *
+ * # Ce qui change en sortant de la page
+ *
+ * Les hachures de danger étaient écrites `rgba(229, 62, 62, .03)` — la valeur
+ * de `--danger` du thème SOMBRE, figée en dur. Elles sont maintenant
+ * `rgb(var(--danger) / .03)`, donc elles suivent le thème. Même correction sur
+ * les deux rehauts blancs du tampon, qui supposaient un fond sombre : ils
+ * prennent la couleur d'avant-plan du tampon (`--danger-fg`), qui bascule avec
+ * lui.
+ */
+const props = withDefaults(
+  defineProps<{
+    /** Le hash demandé, tel qu'il est dans la route. Jamais montré en entier. */
+    hash: string;
+    /**
+     * Le nom de la catégorie, si la charge caviardée en donne un. C'est la
+     * seule chose que le serveur accepte de dire du torrent.
+     */
+    categoryName?: string | null;
+  }>(),
+  { categoryName: null },
+);
+
+const titleId = useId();
+
+/** Le hash, milieu noirci. `abcd…7f0e` plutôt que rien ou tout. */
+const redactedHash = computed(() => {
+  const h = props.hash || '';
+  if (h.length <= 8) return h;
+  return `${h.slice(0, 4)}…${h.slice(-4)}`;
+});
+
+/** `XXX` quand le serveur n'a même pas donné la catégorie. */
+const category = computed(() => props.categoryName || 'XXX');
+</script>
+
+<template>
+  <section class="adult-gate" :aria-labelledby="titleId">
+    <NuxtLink to="/torrents" class="adult-gate__back">
+      <Icon name="ph:arrow-left-bold" />
+      {{ $t('torrents.detail.backToIndex') }}
+    </NuxtLink>
+
+    <div class="adult-gate__panel">
+      <header class="adult-gate__hatch">
+        <span class="adult-gate__hatch-label">
+          <Icon name="ph:eye-slash-fill" />
+          {{ $t('torrents.detail.adultGate.filterActive') }}
+        </span>
+        <span class="adult-gate__hatch-route">
+          /torrents/<span class="adult-gate__hash">{{ redactedHash }}</span>
+        </span>
+      </header>
+
+      <div class="adult-gate__body">
+        <p class="adult-gate__eyebrow">
+          {{ $t('torrents.detail.adultGate.eyebrow') }}
+        </p>
+        <h1 :id="titleId" class="adult-gate__title">
+          <span class="adult-gate__title-word">
+            {{ $t('torrents.detail.adultGate.titleWord') }}
+          </span>
+          <span class="adult-gate__title-stamp" aria-hidden="true">
+            <span class="adult-gate__title-stamp-inner">
+              {{ $t('torrents.detail.adultGate.titleStamp') }}
+            </span>
+          </span>
+        </h1>
+
+        <!-- Trois barres à la place du titre : l'œil lit « il y a un titre
+             ici », le lecteur d'écran ne lit rien du tout. -->
+        <p class="adult-gate__redacted" aria-hidden="true">
+          <span /><span /><span />
+        </p>
+
+        <dl class="adult-gate__meta">
+          <div>
+            <dt>{{ $t('common.category') }}</dt>
+            <dd>{{ category }}</dd>
+          </div>
+          <div>
+            <dt>{{ $t('torrents.detail.adultGate.reasonLabel') }}</dt>
+            <dd>{{ $t('torrents.detail.adultGate.reasonValue') }}</dd>
+          </div>
+          <div>
+            <dt>{{ $t('torrents.detail.adultGate.reachableIn') }}</dt>
+            <dd>{{ $t('torrents.detail.adultGate.reachableValue') }}</dd>
+          </div>
+        </dl>
+
+        <p class="adult-gate__copy">
+          {{ $t('torrents.detail.adultGate.copy') }}
+        </p>
+
+        <div class="adult-gate__actions">
+          <NuxtLink to="/settings" class="adult-gate__cta">
+            <Icon name="ph:eye-bold" />
+            <span>{{ $t('torrents.detail.adultGate.enable') }}</span>
+          </NuxtLink>
+          <NuxtLink to="/torrents" class="adult-gate__cta adult-gate__cta--ghost">
+            <Icon name="ph:list-bold" />
+            <span>{{ $t('torrents.detail.adultGate.browseSafe') }}</span>
+          </NuxtLink>
+        </div>
+      </div>
+
+      <footer class="adult-gate__foot">
+        <span>{{ $t('torrents.detail.adultGate.footer') }}</span>
+        <span class="adult-gate__foot-mono">/settings#adult</span>
+      </footer>
+    </div>
+  </section>
+</template>
+
+<style scoped>
+.adult-gate {
+  display: flex;
+  flex-direction: column;
+  gap: 1.5rem;
+  max-width: 45rem;
+  margin: 1rem auto 4rem;
+  padding: 0 0.25rem;
+}
+
+.adult-gate__back {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+  width: max-content;
+  font-family: var(--font-mono);
+  font-size: var(--label-md, 0.625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+  transition: color var(--dur-2) var(--ease-standard);
+}
+.adult-gate__back:hover {
+  color: rgb(var(--fg-strong));
+}
+
+.adult-gate__panel {
+  position: relative;
+  overflow: hidden;
+  border: 1px solid rgb(var(--line-default));
+  border-left: 3px solid rgb(var(--danger));
+  border-radius: var(--radius-lg);
+  background: rgb(var(--bg-surface));
+  /* Le hachuré de danger, à 3 % : la surface se lit comme un avertissement
+     sans écraser ce qu'elle porte. Le jeton et non le triplet — la valeur
+     écrite en dur était celle du thème sombre, sur fond clair elle virait. */
+  background-image: repeating-linear-gradient(
+    -45deg,
+    transparent,
+    transparent 1rem,
+    rgb(var(--danger) / 0.03) 1rem,
+    rgb(var(--danger) / 0.03) 1.125rem
+  );
+  animation: gate-rise calc(0.45s * var(--motion-scale)) var(--ease-standard) both;
+}
+@keyframes gate-rise {
+  from { opacity: 0; transform: translateY(8px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+.adult-gate__hatch {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+  padding: 0.7rem 1.1rem;
+  border-bottom: 1px solid rgb(var(--line-default));
+  background: repeating-linear-gradient(
+    -45deg,
+    rgb(var(--danger) / 0.18),
+    rgb(var(--danger) / 0.18) 0.875rem,
+    rgb(var(--danger) / 0.06) 0.875rem,
+    rgb(var(--danger) / 0.06) 1.75rem
+  );
+  font-family: var(--font-mono);
+  font-size: var(--label-md, 0.625rem);
+  font-weight: 800;
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-strong));
+}
+.adult-gate__hatch-label {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.55rem;
+  color: rgb(var(--danger));
+}
+.adult-gate__hatch-route {
+  font-weight: 600;
+  letter-spacing: calc(0.06em * var(--tracking-scale));
+  text-transform: lowercase;
+  color: rgb(var(--fg-muted));
+}
+/* Le milieu du hash : avant-plan et fond de la même couleur, donc une barre
+   opaque dans les deux thèmes. Le texte reste dans le DOM. */
+.adult-gate__hash {
+  color: rgb(var(--fg-strong));
+  background: rgb(var(--fg-strong));
+}
+
+.adult-gate__body {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  gap: 1.1rem;
+  padding: 2rem 1.6rem 1.5rem;
+}
+.adult-gate__eyebrow {
+  margin: 0;
+  font-family: var(--font-mono);
+  font-size: var(--label-md, 0.625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+}
+.adult-gate__title {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.6rem;
+  margin: 0;
+  font-size: clamp(2rem, 6vw, 3.4rem);
+  font-weight: 900;
+  line-height: 1;
+  letter-spacing: calc(-0.025em * var(--tracking-scale));
+  text-transform: uppercase;
+  color: rgb(var(--fg-strong));
+}
+.adult-gate__title-word {
+  font-style: italic;
+}
+.adult-gate__title-stamp {
+  position: relative;
+  display: inline-flex;
+  padding: 0.2em 0.6em 0.25em;
+  background: rgb(var(--danger));
+  color: rgb(var(--danger-fg));
+  letter-spacing: calc(0.05em * var(--tracking-scale));
+  /* Une inclinaison hors axe : une vraie empreinte de tampon n'est pas droite. */
+  transform: rotate(-1.5deg);
+  /* Le rehaut prend l'avant-plan DU TAMPON. Écrit en blanc, il supposait un
+     fond sombre et disparaissait en thème clair. */
+  box-shadow:
+    inset 0 0 0 2px rgb(var(--danger-fg) / 0.18),
+    0 1px 0 rgb(var(--shadow-color) / calc(0.4 * var(--shadow-strength)));
+}
+.adult-gate__title-stamp::after {
+  content: '';
+  position: absolute;
+  inset: -2px;
+  border: 2px dashed rgb(var(--danger-fg) / 0.35);
+  pointer-events: none;
+}
+.adult-gate__title-stamp-inner {
+  position: relative;
+  display: inline-block;
+}
+
+.adult-gate__redacted {
+  display: flex;
+  flex-direction: column;
+  gap: 0.45rem;
+  margin: 0.5rem 0 0.25rem;
+}
+.adult-gate__redacted span {
+  display: block;
+  height: 0.95rem;
+  border-radius: 1px;
+  background: rgb(var(--fg-strong));
+  animation: gate-bar calc(1.2s * var(--motion-scale)) cubic-bezier(0.2, 0.6, 0.2, 1) both;
+}
+.adult-gate__redacted span:nth-child(1) { width: 78%; animation-delay: calc(0.05s * var(--motion-scale)); }
+.adult-gate__redacted span:nth-child(2) { width: 64%; animation-delay: var(--dur-1); }
+.adult-gate__redacted span:nth-child(3) { width: 42%; animation-delay: calc(0.19s * var(--motion-scale)); }
+@keyframes gate-bar {
+  0% { transform: scaleX(0.05); transform-origin: left; opacity: 0.2; }
+  60% { transform: scaleX(1.04); opacity: 1; }
+  100% { transform: scaleX(1); opacity: 1; }
+}
+
+.adult-gate__meta {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 0.65rem;
+  margin: 0.4rem 0 0.5rem;
+  padding: 0.85rem 1rem;
+  border: 1px solid rgb(var(--line-default));
+  border-radius: var(--radius-md);
+  background: rgb(var(--bg-elevated) / 0.6);
+}
+.adult-gate__meta div {
+  display: flex;
+  flex-direction: column;
+  gap: 0.2rem;
+}
+.adult-gate__meta dt {
+  margin: 0;
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+}
+.adult-gate__meta dd {
+  margin: 0;
+  font-family: var(--font-mono);
+  font-size: 0.78125rem;
+  font-weight: 700;
+  color: rgb(var(--fg-strong));
+}
+
+.adult-gate__copy {
+  max-width: 56ch;
+  margin: 0;
+  font-size: 0.8125rem;
+  line-height: 1.55;
+  color: rgb(var(--fg-default));
+}
+
+.adult-gate__actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.6rem;
+  margin-top: 0.4rem;
+}
+.adult-gate__cta {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.55rem;
+  padding: 0.7rem 1.05rem;
+  border: 1px solid rgb(var(--danger));
+  border-radius: var(--radius-pill);
+  background: rgb(var(--danger));
+  color: rgb(var(--danger-fg));
+  font-family: var(--font-mono);
+  font-size: var(--label-lg, 0.6875rem);
+  font-weight: 800;
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+  text-transform: uppercase;
+  transition: filter var(--dur-2) var(--ease-standard);
+}
+.adult-gate__cta:hover {
+  filter: brightness(1.1);
+}
+.adult-gate__cta--ghost {
+  border-color: rgb(var(--line-default));
+  background: transparent;
+  color: rgb(var(--fg-strong));
+}
+.adult-gate__cta--ghost:hover {
+  border-color: rgb(var(--fg-default) / 0.4);
+  filter: none;
+}
+
+.adult-gate__foot {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.75rem;
+  padding: 0.65rem 1.1rem;
+  border-top: 1px dashed rgb(var(--line-default));
+  background: rgb(var(--bg-surface));
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+}
+.adult-gate__foot-mono {
+  text-transform: lowercase;
+  letter-spacing: calc(0.04em * var(--tracking-scale));
+  color: rgb(var(--fg-default));
+}
+
+/* 33.75rem = les 540px d'origine. En requête de média, `rem` vaut toujours la
+   taille INITIALE de la racine, donc le point de bascule ne bouge pas avec
+   `--ui-scale` — c'est la seule unité qui garde ici le sens de la valeur en
+   pixels qu'elle remplace. */
+@media (max-width: 33.75rem) {
+  .adult-gate__meta {
+    grid-template-columns: 1fr;
+  }
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/BuffsForm.vue b/apps/web/app/components/torrent/detail/BuffsForm.vue
new file mode 100644
index 00000000..2d6159b6
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/BuffsForm.vue
@@ -0,0 +1,292 @@
+<script setup lang="ts">
+import { datetimeLocalToIso, isoToDatetimeLocal } from '~/utils/format';
+
+/**
+ * Les multiplicateurs d'une release, et son épinglage.
+ *
+ * # Deux droits dans un seul formulaire
+ *
+ * Épingler est éditorial : n'importe quel modérateur peut le faire. Les
+ * multiplicateurs frappent du crédit, et seul un administrateur y touche. Le
+ * formulaire dit lequel est lequel en désactivant les trois champs plutôt qu'en
+ * cachant un 403 derrière un bouton qui a l'air disponible.
+ *
+ * Et `save` envoie **uniquement** `isSticky` quand celui qui l'actionne n'est
+ * pas administrateur : la route refuse les multiplicateurs, donc les envoyer
+ * quand même transformerait chaque épinglage en 403.
+ *
+ * # Pourquoi l'état du formulaire n'est pas la ligne
+ *
+ * Un `datetime-local` veut `AAAA-MM-JJTHH:mm` en heure LOCALE, la ligne porte
+ * un instant ISO. Les deux ne peuvent pas partager une référence sans que l'une
+ * soit fausse. On amorce une fois, on convertit à l'enregistrement, et la
+ * conversion vit à un seul endroit — `toISOString().slice(0, 16)` écrivait
+ * l'heure UTC dans un champ qui la relit comme locale, donc l'échéance reculait
+ * d'un fuseau à chaque enregistrement.
+ *
+ * # Les libellés
+ *
+ * Chaque contrôle reste ENVELOPPÉ dans son `<label>`. C'est ce qui lui donne
+ * son nom accessible, et `test/formControlNames.test.ts` casse la construction
+ * si l'un d'eux en sort sans un `for`/`id` apparié pour le remplacer.
+ */
+const props = withDefaults(
+  defineProps<{
+    /** Le hash, pour `PUT /api/mod/torrents/:hash/buffs`. */
+    hash: string;
+    /** La ligne, dont le formulaire s'amorce. Tout est optionnel : le détail
+     *  arrive en `Record<string, any>` et rien ici n'est garanti présent. */
+    torrent?: {
+      downloadMultiplier?: number;
+      uploadMultiplier?: number;
+      multipliersUntil?: string | null;
+      isSticky?: boolean;
+    } | null;
+    /** Un modérateur voit le formulaire ; seul un administrateur l'édite. */
+    isAdmin?: boolean;
+  }>(),
+  { torrent: null, isAdmin: false },
+);
+
+const emit = defineEmits<{
+  /** Une écriture a abouti : la page peut recharger la ligne. */
+  (e: 'changed'): void;
+}>();
+
+const { t } = useI18n();
+const notifications = useNotificationStore();
+
+const form = reactive({
+  downloadMultiplier: 100,
+  uploadMultiplier: 100,
+  until: '',
+  isSticky: false,
+});
+const busy = ref(false);
+
+watch(
+  () => props.torrent,
+  (row) => {
+    if (!row) return;
+    form.downloadMultiplier = row.downloadMultiplier ?? 100;
+    form.uploadMultiplier = row.uploadMultiplier ?? 100;
+    form.isSticky = row.isSticky ?? false;
+    form.until = isoToDatetimeLocal(row.multipliersUntil);
+  },
+  // Pas de `deep` : la page remplace l'objet entier à chaque rechargement, et
+  // c'est ce remplacement — pas une mutation interne — qui doit ré-amorcer le
+  // formulaire. En profondeur, une frappe dans un autre champ de la ligne
+  // écraserait ce que l'exploitant est en train de saisir.
+  { immediate: true },
+);
+
+/**
+ * La release porte-t-elle un buff, oui ou non.
+ *
+ * Même règle que le badge : un buff échu se lit comme aucun buff, et `1× / 1×`
+ * n'en est pas un. C'est ce qui décide si « retirer le buff » a quelque chose
+ * à retirer.
+ */
+const hasBuff = computed(() => {
+  const row = props.torrent;
+  if (!row || row.downloadMultiplier === undefined || row.uploadMultiplier === undefined) {
+    return false;
+  }
+  if (row.multipliersUntil && new Date(row.multipliersUntil) <= new Date()) return false;
+  return !(row.downloadMultiplier === 100 && row.uploadMultiplier === 100);
+});
+
+async function put(body: Record<string, unknown>) {
+  busy.value = true;
+  try {
+    await $fetch(`/api/mod/torrents/${props.hash}/buffs`, { method: 'PUT', body });
+    emit('changed');
+    notifications.success(t('torrents.detail.buffs.saved'));
+  } catch (err: unknown) {
+    const e = err as { data?: { message?: string }; message?: string };
+    notifications.error(
+      e?.data?.message || e?.message || t('torrents.detail.buffs.failed'),
+    );
+  } finally {
+    busy.value = false;
+  }
+}
+
+function save() {
+  // Un modérateur n'envoie QUE l'épingle. Les multiplicateurs seraient refusés.
+  if (!props.isAdmin) return put({ isSticky: form.isSticky });
+  return put({
+    downloadMultiplier: form.downloadMultiplier,
+    uploadMultiplier: form.uploadMultiplier,
+    until: datetimeLocalToIso(form.until),
+    isSticky: form.isSticky,
+  });
+}
+
+function clear() {
+  return put({ downloadMultiplier: 100, uploadMultiplier: 100, until: null });
+}
+</script>
+
+<template>
+  <section class="section">
+    <SectionHead :title="$t('torrents.detail.buffs.title')" icon="ph:sparkle" />
+
+    <p class="buffs-lede">{{ $t('torrents.detail.buffs.lede') }}</p>
+
+    <div class="buffs-grid">
+      <label class="buffs-field">
+        <span class="field-label">{{ $t('torrents.detail.buffs.download') }}</span>
+        <select v-model.number="form.downloadMultiplier" class="input" :disabled="!isAdmin">
+          <option :value="0">0× — {{ $t('torrent.buff.freeleech') }}</option>
+          <option :value="50">0.5× — {{ $t('torrent.buff.silverleech') }}</option>
+          <option :value="100">1× — {{ $t('torrents.detail.buffs.normal') }}</option>
+        </select>
+      </label>
+
+      <label class="buffs-field">
+        <span class="field-label">{{ $t('torrents.detail.buffs.upload') }}</span>
+        <select v-model.number="form.uploadMultiplier" class="input" :disabled="!isAdmin">
+          <option :value="100">1× — {{ $t('torrents.detail.buffs.normal') }}</option>
+          <option :value="150">1.5×</option>
+          <option :value="200">2× — {{ $t('torrent.buff.doubleUpload') }}</option>
+          <option :value="300">3×</option>
+        </select>
+      </label>
+
+      <label class="buffs-field">
+        <span class="field-label">{{ $t('torrents.detail.buffs.until') }}</span>
+        <input v-model="form.until" type="datetime-local" class="input" :disabled="!isAdmin" />
+        <span class="buffs-hint">{{ $t('torrents.detail.buffs.untilHint') }}</span>
+      </label>
+
+      <!-- Le `<span>` vide n'est pas un oubli : il rend à la case la même boîte
+           que ses voisins, dont le libellé occupe cette place. Voir le style. -->
+      <div class="buffs-field buffs-field--toggle">
+        <span class="field-label" aria-hidden="true">&nbsp;</span>
+        <label class="buffs-toggle">
+          <input v-model="form.isSticky" type="checkbox" />
+          <span>{{ $t('torrents.detail.buffs.pin') }}</span>
+        </label>
+      </div>
+    </div>
+
+    <div class="buffs-actions">
+      <button type="button" class="btn btn-secondary" :disabled="busy" @click="save">
+        <Icon
+          :name="busy ? 'ph:circle-notch' : 'ph:check-bold'"
+          :class="{ 'animate-spin': busy }"
+        />
+        {{ $t('torrents.detail.buffs.save') }}
+      </button>
+      <button
+        v-if="hasBuff"
+        type="button"
+        class="btn-ghost"
+        :disabled="busy || !isAdmin"
+        @click="clear"
+      >
+        {{ $t('torrents.detail.buffs.clear') }}
+      </button>
+    </div>
+  </section>
+</template>
+
+<style scoped>
+/* `.section` était une classe de la PAGE, pas une classe globale. Chaque
+   composant sorti d'elle porte sa propre copie — c'est le piège dans lequel
+   `.tool-btn` est tombée ici : utilisée par cinq fichiers, définie dans deux. */
+.section {
+  /* Même bloc que dans `AdminSwarmTable.vue`, `SupersedeForm.vue` et
+     `FederationSwarmToggle.vue` : quatre copies d'un motif que la page
+     possédait et que `main.css` ne connaît pas. Le rail bleu est la marque de
+     la famille « exploitation » ; il est ajouté aux quatre à l'identique, et
+     l'en-tête de `AdminSwarmTable.vue` porte la mesure. */
+  --section-tone: var(--chart-1);
+  padding: 1rem 1.1rem;
+  border: 1px solid rgb(var(--line-default));
+  border-left: 3px solid rgb(var(--chart-1) / 0.55);
+  border-radius: var(--radius-lg);
+  background: rgb(var(--bg-surface));
+}
+
+.buffs-lede {
+  max-width: 62ch;
+  margin: 0 0 1rem;
+  font-size: 0.8125rem;
+  line-height: 1.55;
+  color: rgb(var(--fg-muted));
+}
+.buffs-grid {
+  display: flex;
+  flex-wrap: wrap;
+  /*
+   * Par le HAUT, et c'était `flex-end`.
+   *
+   * Aligner les bas de groupes marche tant que les groupes font la même
+   * hauteur. Celui de « Fin » porte une aide sous son champ — 83 px contre 59
+   * — donc son libellé remontait de vingt-quatre pixels au-dessus de ceux de
+   * « Téléchargement » et « Envoi ». Un champ décalé dans une rangée de trois.
+   *
+   * Par le haut, les trois libellés s'alignent, les trois contrôles aussi
+   * (les blocs de libellé ont la même hauteur), et seule l'aide dépasse en
+   * dessous — là où elle doit être.
+   */
+  align-items: flex-start;
+  gap: 0.85rem;
+}
+.buffs-field {
+  display: flex;
+  flex-direction: column;
+  gap: 0.3rem;
+  min-width: 11rem;
+}
+.buffs-hint {
+  font-size: 0.7rem;
+  color: rgb(var(--fg-subtle));
+}
+/*
+ * La case n'a pas de libellé au-dessus, donc l'alignement par le haut la
+ * mettait au niveau des LIBELLÉS et non des contrôles. Plutôt qu'un décalage
+ * calculé à la main — l'ancien `padding-bottom: 0.55rem` était exactement ça,
+ * la compensation du `flex-end` d'avant — elle reçoit un libellé VIDE : même
+ * structure que ses voisins, donc même géométrie, sans un seul nombre magique.
+ */
+.buffs-toggle {
+  /* La case fait 13 x 13 px : c'est le `<label>` qui doit porter la cible, et
+     il ne la portait pas — il épousait la hauteur du texte. */
+  min-height: 1.5rem;
+}
+/* La seule case à cocher de la fiche qui gardait l'apparence brute du
+   navigateur : même teinte que le reste, et 16 px au lieu de 13. */
+.buffs-toggle input {
+  width: 1rem;
+  height: 1rem;
+  accent-color: rgb(var(--accent));
+}
+.buffs-toggle {
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+  font-size: 0.8125rem;
+  cursor: pointer;
+}
+.buffs-actions {
+  display: flex;
+  align-items: center;
+  gap: 0.6rem;
+  margin-top: 1rem;
+}
+
+@media (max-width: 40rem) {
+  .buffs-field {
+    flex: 1 1 100%;
+    min-width: 0;
+  }
+}
+/* Elle ne porte pas de champ : la largeur minimale des autres colonnes la
+   ferait passer seule à la ligne bien avant qu'il ne le faille. */
+.buffs-field--toggle {
+  min-width: 0;
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/DecisionCard.vue b/apps/web/app/components/torrent/detail/DecisionCard.vue
new file mode 100644
index 00000000..717cc0a9
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/DecisionCard.vue
@@ -0,0 +1,622 @@
+<script setup lang="ts">
+import type { CrossSeedStats, SeedObligation } from '~/composables/useTorrentDetail';
+
+/**
+ * « Puis-je la prendre, et devrais-je ? » — une carte, quatre bandes.
+ *
+ * # Pourquoi une seule carte
+ *
+ * Les quatre réponses sont une seule décision : les chiffres du swarm, le
+ * bouton, ce que la release coûte (ou ne coûte pas), et ce qu'elle engage.
+ * Éclatées en quatre cartes, elles se lisent comme quatre sujets et le membre
+ * clique avant d'avoir vu l'obligation — qui est justement celle des quatre
+ * qu'il regretterait d'avoir manquée. Des filets d'un pixel séparent les
+ * bandes ; rien d'autre. Conteneurs identiques, seule la couleur différencie.
+ *
+ * # Pourquoi la barre d'action est un slot
+ *
+ * « Signaler », « Favori », « Demander des seeds », « Modifier » dépendent de
+ * quatre permissions et d'un compteur de seeders à zéro. Les faire entrer ici
+ * demanderait six props booléennes que cette carte ne saurait pas quoi
+ * vérifier — et la page les tient déjà toutes. Elle place donc ses contrôles
+ * dans la bande ; la carte n'en fournit que la mise en page.
+ *
+ * # Couleur
+ *
+ * Aucune bande n'est peinte de la couleur de son propre texte. La bande de
+ * bonus, la seule tentée de l'être, porte un fond neutre, un filet chaud à
+ * gauche et une pastille sur la paire prévue pour ça
+ * (`--accent-warm` / `--accent-warm-fg`). Le voile chaud sous un texte chaud
+ * fait tomber la paire sous 4,5:1 en thème clair.
+ */
+const props = withDefaults(
+  defineProps<{
+    /** Taille du contenu, en octets. */
+    size?: number | null;
+    /** Nombre de fichiers, pour la sous-ligne de la taille. */
+    fileCount?: number | null;
+    stats?: { seeders: number; leechers: number; completed: number } | null;
+    /** Les chiffres de cross-seed. Les octets arrivent en CHAÎNES (BigInt). */
+    crossSeedStats?: CrossSeedStats | null;
+    /** Le multiplicateur actif, tel que le dérive `useTorrentDetail`. */
+    buff?: { kind: string; dl: number; ul: number; until: string | null } | null;
+    /** « 0× DL · 2× UL », déjà composé et localisé par le composable. */
+    buffPair?: string | null;
+    /** « dans 3 jours », déjà composé par le composable. */
+    buffEndsIn?: string | null;
+    obligation?: SeedObligation | null;
+    /** Un titre de section au-dessus des chiffres, quand la page en veut un. */
+    title?: string | null;
+    /**
+     * Le compteur du membre — envoyé / reçu, en octets — pour dire ce que ce
+     * téléchargement fait à son ratio AVANT qu'il clique. `null` quand
+     * personne n'est connecté : la bande ne se rend pas.
+     */
+    viewerStats?: { uploaded: number; downloaded: number } | null;
+    /** L'infohash, pour que la santé de l'essaim aille chercher sa courbe. */
+    hash?: string | null;
+    /** Les pairs anonymisés de la fiche, pour la dernière annonce. */
+    peers?: ReadonlyArray<{ lastSeen?: string | null }> | null;
+  }>(),
+  {
+    size: null,
+    fileCount: null,
+    stats: null,
+    crossSeedStats: null,
+    buff: null,
+    buffPair: null,
+    buffEndsIn: null,
+    obligation: null,
+    title: null,
+    viewerStats: null,
+    hash: null,
+    peers: null,
+  },
+);
+
+const { t, locale } = useI18n();
+
+const num = (n: number) => n.toLocaleString(locale.value);
+
+/**
+ * Une valeur qui change pendant que la carte est affichée glisse vers le haut
+ * (la `<Transition>` sur la clé) et sa tuile se teinte une demi-seconde : rien
+ * ne signalait qu'un chiffre venait d'être rafraîchi. Jamais au premier rendu.
+ */
+const flash = reactive({ seed: false, leech: false, done: false });
+const timers: Partial<Record<keyof typeof flash, ReturnType<typeof setTimeout>>> = {};
+function pulse(k: keyof typeof flash) {
+  flash[k] = false;
+  requestAnimationFrame(() => { flash[k] = true; });
+  if (timers[k]) clearTimeout(timers[k]);
+  timers[k] = setTimeout(() => (flash[k] = false), 700);
+}
+watch(() => props.stats?.seeders, (n, o) => { if (o !== undefined && n !== o) pulse('seed'); });
+watch(() => props.stats?.leechers, (n, o) => { if (o !== undefined && n !== o) pulse('leech'); });
+watch(() => props.stats?.completed, (n, o) => { if (o !== undefined && n !== o) pulse('done'); });
+onBeforeUnmount(() => { for (const t of Object.values(timers)) if (t) clearTimeout(t); });
+
+/** Combien de seeders par leecher — la santé du swarm en un chiffre. */
+const ratio = computed(() => {
+  const s = props.stats;
+  if (!s) return null;
+  const value = s.leechers > 0 ? s.seeders / s.leechers : s.seeders;
+  return value.toLocaleString(locale.value, { maximumFractionDigits: 1 });
+});
+
+/**
+ * Les octets de cross-seed, en nombres.
+ *
+ * Le fil les porte en chaînes parce que le total dépasse `Number.MAX_SAFE_INTEGER`
+ * chez les gros échangeurs. `Number()` d'une chaîne vide ou absente donne `0`
+ * plutôt que `NaN`, mais `Number(undefined)` donne `NaN` — d'où le `?? '0'`.
+ */
+const exchanged = computed(() => {
+  const cs = props.crossSeedStats;
+  const total = Number(cs?.totalUploadedBytes ?? '0');
+  const share = Number(cs?.uploadedShareBytes ?? '0');
+  const ok = Number.isFinite(total) && Number.isFinite(share);
+  return {
+    total: ok ? total : 0,
+    share: ok ? share : 0,
+    fraction: ok && total > 0 ? share / total : 0,
+  };
+});
+
+const sharePercent = computed(() =>
+  exchanged.value.fraction.toLocaleString(locale.value, {
+    style: 'percent',
+    maximumFractionDigits: 1,
+  }),
+);
+
+const showExchanged = computed(() => exchanged.value.total > 0);
+
+/** La ligne de détail cross-seed : elle n'existe que s'il y a du trafic. */
+const showCrossSeedLine = computed(() => {
+  const cs = props.crossSeedStats;
+  if (!cs) return false;
+  return exchanged.value.share > 0 || cs.seederCount > 0 || cs.leecherCount > 0;
+});
+
+/** La pastille du bonus : courte, c'est elle qu'on lit de loin. */
+/**
+ * Ce que ce téléchargement fait au ratio du membre.
+ *
+ * C'est l'information qui décide vraiment d'un téléchargement sur un tracker
+ * privé, et elle n'était affichée nulle part : il fallait connaître sa taille,
+ * son propre compteur et le multiplicateur en cours, puis calculer de tête.
+ * Tout est déjà dans la page ; on fait le calcul à la place du membre.
+ *
+ * Le multiplicateur de TÉLÉCHARGEMENT est celui qui compte ici (`buff.dl`, en
+ * pourcentage — 0 en freeleech, 100 en temps normal). Le multiplicateur d'envoi
+ * ne change pas ce que le clic coûte, seulement ce que le partage rapportera.
+ */
+const cost = computed(() => {
+  const v = props.viewerStats;
+  if (!v || typeof props.size !== 'number' || props.size <= 0) return null;
+  const up = Math.max(0, Number(v.uploaded) || 0);
+  const down = Math.max(0, Number(v.downloaded) || 0);
+  const factor = props.buff ? Math.max(0, props.buff.dl) / 100 : 1;
+  const counted = props.size * factor;
+  const fmt = (x: number) =>
+    x.toLocaleString(locale.value, { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+  const before = down > 0 ? up / down : null;
+  const after = down + counted > 0 ? up / (down + counted) : null;
+  const afterWithout = down + props.size > 0 ? up / (down + props.size) : null;
+  // « Inchangé » se juge sur ce qui s'AFFICHE : 1,4 GiB contre 290 GiB reçus
+  // fait passer 1,4157 à 1,4090, et les deux s'écrivent « 1,42 ». Montrer
+  // « 1,42 → 1,42 » sans un mot dessus ressemblait à une erreur ; le mot le
+  // dit, et la flèche disparaît.
+  const beforeTxt = before === null ? null : fmt(before);
+  const afterTxt = after === null ? null : fmt(after);
+  return {
+    before: beforeTxt,
+    after: afterTxt,
+    unchanged: beforeTxt !== null && afterTxt !== null && beforeTxt === afterTxt,
+    kind: factor === 0 ? 'freeleech' : factor < 1 ? 'partial' : 'full',
+    factorLabel: factor.toLocaleString(locale.value, { maximumFractionDigits: 2 }),
+    // Ce que ça aurait coûté sans le bonus — pour mesurer ce que le bonus vaut.
+    without:
+      factor < 1 && before !== null && afterWithout !== null
+        ? { before: fmt(before), after: fmt(afterWithout) }
+        : null,
+  };
+});
+
+const buffBadge = computed(() => {
+  const b = props.buff;
+  if (!b) return null;
+  if (b.kind === 'freeleech') return t('torrents.detail.buff.freeleech');
+  if (b.kind === 'upload') {
+    return t('torrents.detail.buff.upload', {
+      n: (b.ul / 100).toLocaleString(locale.value),
+    });
+  }
+  return t('torrents.detail.buff.mixed');
+});
+
+/** Ce que le bonus change, en une phrase. */
+const buffNote = computed(() => {
+  const b = props.buff;
+  if (!b) return null;
+  if (b.kind === 'freeleech') return t('torrents.detail.buff.freeleechNote');
+  if (b.kind === 'upload') {
+    return t('torrents.detail.buff.uploadNote', {
+      n: (b.ul / 100).toLocaleString(locale.value),
+    });
+  }
+  return t('torrents.detail.buff.mixedNote');
+});
+
+/*
+ * `cta` compte, et son absence ici est ce qui a fait rendre la page sans
+ * aucun bouton de téléchargement : le gabarit ne posait pas de
+ * `<slot name="cta" />`, Vue ne prévient pas pour un slot passé et jamais
+ * rendu, et le seul CTA restant était celui du dock — masqué au-delà du
+ * seuil mobile. Sur un écran large, la page n'offrait plus AUCUN moyen de
+ * prendre le torrent, et ni le typecheck ni les tests ne pouvaient le voir.
+ */
+</script>
+
+<template>
+  <div class="card dc">
+    <div v-if="title" class="dc-band dc-band--head">
+      <SectionHead :title="title" level="h2" compact />
+    </div>
+
+    <!-- ── Le geste. En tête de la carte, pleine largeur : dans la colonne
+         épinglée c'est la première chose sous les yeux et elle y reste
+         pendant qu'on lit les 3 000 px du dessous. Les boutons secondaires
+         (favoris, signaler…) ne sont plus ici : ils ont leur propre carte
+         « Vos actions », plus bas dans la colonne, où le rouge de
+         « Supprimer » ne voisine plus le bouton principal. ─────────────── -->
+    <div v-if="$slots.cta" class="dc-band dc-band--cta">
+      <slot name="cta" />
+    </div>
+
+    <!-- ── La santé de l'essaim : l'état en un mot, la dernière annonce, la
+         tendance. Juste sous le geste, parce que c'est ce qu'on veut savoir
+         avant de le faire. ───────────────────────────────────────────────── -->
+    <div v-if="hash && stats" class="dc-band">
+      <TorrentDetailSwarmHealth :hash="hash" :stats="stats" :peers="peers" />
+    </div>
+
+    <!-- ── Les chiffres. Une réglette, pas quatre tuiles : dans une colonne de
+         21,5 rem, quatre boîtes de 150 px empilées deux par deux faisaient une
+         tour de cartons sous le bouton — mesuré, 310 px pour trois nombres. La
+         taille est déjà sous le bouton ; restent les trois faits de l'essaim,
+         côte à côte, séparés d'un filet. Une liste de définitions quand même :
+         un lecteur d'écran annonce la nature avant la valeur. ──────────── -->
+    <div v-if="stats || showExchanged" class="dc-band">
+      <dl class="dc-strip">
+        <div v-if="stats" class="dc-cell dc-cell--seed" :data-changed="flash.seed || undefined">
+          <dt class="dc-k">{{ $t('torrents.detail.stats.seeders') }}</dt>
+          <!-- Le chevron double la couleur (`color-not-only`) ; `aria-hidden`,
+               le `<dt>` a déjà nommé la valeur. -->
+          <dd class="dc-v">
+            <Icon name="ph:caret-up-fill" class="dc-glyph" aria-hidden="true" />
+            <Transition name="dcn" mode="out-in"><span :key="stats.seeders">{{ num(stats.seeders) }}</span></Transition>
+          </dd>
+          <!-- « 0 par leecher » sous zéro source ne dit rien : la ligne ne se
+               rend qu'avec au moins une source. -->
+          <dd v-if="ratio && stats.seeders > 0" class="dc-s">
+            {{ $t('torrents.detail.decision.perLeecher', { value: ratio }) }}
+          </dd>
+        </div>
+        <div v-if="stats" class="dc-cell dc-cell--leech" :data-changed="flash.leech || undefined">
+          <dt class="dc-k">{{ $t('torrents.detail.stats.leechers') }}</dt>
+          <dd class="dc-v">
+            <Icon name="ph:caret-down-fill" class="dc-glyph" aria-hidden="true" />
+            <Transition name="dcn" mode="out-in"><span :key="stats.leechers">{{ num(stats.leechers) }}</span></Transition>
+          </dd>
+          <dd class="dc-s">{{ $t('torrents.detail.decision.inProgress') }}</dd>
+        </div>
+        <div v-if="stats" class="dc-cell" :data-changed="flash.done || undefined">
+          <dt class="dc-k">{{ $t('torrents.detail.stats.completed') }}</dt>
+          <dd class="dc-v">
+            <Transition name="dcn" mode="out-in"><span :key="stats.completed">{{ num(stats.completed) }}</span></Transition>
+          </dd>
+          <dd class="dc-s">{{ $t('torrents.detail.decision.snatches') }}</dd>
+        </div>
+        <div v-if="showExchanged" class="dc-cell">
+          <dt class="dc-k">{{ $t('torrents.detail.stats.exchanged') }}</dt>
+          <dd class="dc-v">{{ formatSize(exchanged.total) }}</dd>
+          <dd class="dc-s">
+            {{ $t('torrents.detail.decision.xseedShare', { percent: sharePercent }) }}
+          </dd>
+        </div>
+      </dl>
+
+      <p v-if="showCrossSeedLine && crossSeedStats" class="dc-xseed">
+        <span>
+          {{
+            $t('torrents.detail.decision.xseedSwarm', {
+              seeders: num(crossSeedStats.seederCount),
+              leechers: num(crossSeedStats.leecherCount),
+            })
+          }}
+        </span>
+        <span v-if="exchanged.share > 0">
+          {{
+            $t('torrents.detail.decision.xseedBytes', {
+              size: formatSize(exchanged.share),
+              percent: sharePercent,
+            })
+          }}
+        </span>
+      </p>
+    </div>
+
+    <!-- ── Ce que ça vous coûte. Le ratio avant → après, freeleech compris :
+         la seule ligne de la carte qui parle du MEMBRE et non de la release,
+         et celle qu'il calculait de tête jusqu'ici. ─────────────────────── -->
+    <div v-if="cost" class="dc-band">
+      <div class="dc-cost">
+        <span class="dc-k">{{ $t('torrents.detail.cost.title') }}</span>
+        <p v-if="cost.before !== null && cost.after !== null" class="dc-cost-ratio">
+          <span class="dc-cost-n" :class="{ 'dc-cost-n--same': cost.unchanged }">{{ cost.before }}</span>
+          <template v-if="!cost.unchanged">
+            <Icon name="ph:arrow-right" class="dc-cost-arrow" aria-hidden="true" />
+            <span class="dc-cost-n">{{ cost.after }}</span>
+          </template>
+          <span v-else class="dc-cost-tag">{{ $t('torrents.detail.cost.unchanged') }}</span>
+        </p>
+        <p v-else class="dc-cost-note">{{ $t('torrents.detail.cost.noRatio') }}</p>
+        <p class="dc-cost-note">
+          <!-- Gratuit : le bandeau GRATUIT dessous dit déjà « ne compte pas dans
+               votre ratio » — ici, seulement ce qu'on aurait payé sans lui.
+               Plein tarif et « ratio inchangé » : « il compte en entier » à côté
+               d'un ratio qui ne bouge pas se lisait comme une contradiction ; la
+               note explique pourquoi les deux sont vrais. -->
+          <template v-if="cost.kind === 'freeleech'">
+            <template v-if="cost.without">{{ $t('torrents.detail.cost.without', { before: cost.without.before, after: cost.without.after }) }}</template>
+            <template v-else>{{ $t('torrents.detail.buff.freeleechNote') }}</template>
+          </template>
+          <template v-else-if="cost.kind === 'partial'">
+            {{ $t('torrents.detail.cost.partial', { n: cost.factorLabel }) }}
+            <template v-if="cost.without">{{ ' ' }}{{ $t('torrents.detail.cost.without', { before: cost.without.before, after: cost.without.after }) }}</template>
+          </template>
+          <template v-else-if="cost.unchanged">{{ $t('torrents.detail.cost.fullUnchanged') }}</template>
+          <template v-else>{{ $t('torrents.detail.cost.full') }}</template>
+        </p>
+      </div>
+    </div>
+
+    <!-- ── Le bonus. La seule bande qui a le droit d'être chaude — et elle
+         l'est par un filet, pas par un voile. ───────────────────────────── -->
+    <div v-if="buff" class="dc-band">
+      <div class="dc-buff">
+        <span class="dc-buff-badge">{{ buffBadge }}</span>
+        <span v-if="buffPair" class="dc-buff-pair">{{ buffPair }}</span>
+        <span v-if="buffNote" class="dc-buff-note">{{ buffNote }}</span>
+        <span v-if="buffEndsIn" class="dc-buff-until">
+          {{ $t('torrents.detail.buff.until', { left: buffEndsIn }) }}
+        </span>
+      </div>
+    </div>
+
+    <!-- ── Ce que la release engage. En dernier parce qu'on la lit après avoir
+         décidé de la prendre — mais AVANT d'avoir cliqué, ce qui est tout
+         l'intérêt de la garder dans la même carte. ──────────────────────── -->
+    <div v-if="obligation" class="dc-band">
+      <TorrentDetailSeedObligationCard :obligation="obligation" />
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.dc {
+  /* La carte de décision est la seule qui parle de LA release : sa famille est
+     l'or du site, et `SectionHead` l'hérite sans qu'on lui passe rien. */
+  --section-tone: var(--accent-warm);
+  /* Les bandes recouvrent le rayon de la carte : sans lui, le filet du haut
+     traverse l'arrondi et laisse deux pointes qui dépassent. */
+  overflow: hidden;
+  /* Un liseré chaud d'un pixel en haut de la carte. Non textuel, donc soumis
+     aux 3:1 de la 1.4.11 et non aux 4,5:1 : `--accent-warm` sur les surfaces
+     de la fiche donne 7,02:1 au pire en sombre et 3,05:1 au pire en clair.
+     C'est ce qui distingue cette carte des douze autres conteneurs de la
+     page, qui étaient rigoureusement identiques. */
+  box-shadow: inset 0 2px 0 rgb(var(--accent-warm) / 0.55);
+}
+
+.dc-band {
+  padding: 0.6rem 0.85rem;
+}
+/* Un filet d'un pixel, jamais un fond différent : les conteneurs sont
+   identiques et c'est la position qui porte le sens. */
+.dc-band + .dc-band {
+  border-top: 1px solid rgb(var(--line-default));
+}
+.dc-band--head {
+  padding-bottom: 0;
+}
+
+/* ── Les cellules de chiffres ─────────────────────────────────────────────── */
+
+/* Le rail de tête : deux pixels de la teinte de la cellule. Non textuel. */
+
+.dc-k {
+  display: block;
+  margin-bottom: 0.1rem;
+  /* `rem` et non `px` : `--ui-scale` n'agit qu'une fois, sur
+     `html { font-size }`. */
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: 700;
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-subtle));
+}
+
+/* Le point focal de la fiche.
+   Recensement d'avant : la plus grosse chose d'un document de 3 830 px faisait
+   23 px, et ces chiffres — les seuls que le membre lit pour décider — en
+   faisaient 16, soit la taille du texte courant. Les deux références font
+   l'inverse : leur bandeau de chiffres est ce qui saute aux yeux. La mono
+   plutôt que l'Inter parce que c'est la police des données sur ce site, et que
+   des chiffres tabulaires de deux lignes voisines doivent s'aligner. */
+.dc-v {
+  display: flex;
+  align-items: center;
+  gap: 0.15rem;
+  margin: 0;
+  font-family: var(--font-mono);
+  font-size: 1.25rem;
+  font-weight: 700;
+  line-height: 1.15;
+  letter-spacing: calc(-0.02em * var(--tracking-scale));
+  font-variant-numeric: tabular-nums;
+  color: rgb(var(--fg-strong));
+  overflow-wrap: anywhere;
+}
+/* Le chevron prend la teinte du chiffre et 0,7 de sa taille : il accompagne,
+   il ne concurrence pas. */
+.dc-glyph {
+  flex: none;
+  font-size: 0.7em;
+  color: rgb(var(--cell-tone));
+}
+/* Couleur sémantique dans des conteneurs identiques : on lit la position, la
+   couleur ne fait que confirmer, et le chevron la confirme une deuxième fois
+   sans couleur. Mesuré sur `--bg-inset` : `--online` 8,41:1 en sombre et
+   4,60:1 en clair, `--info` 8,95:1 et 5,44:1. */
+.dc-cell--seed .dc-v,
+.dc-cell--leech .dc-v {
+  color: rgb(var(--cell-tone));
+}
+
+.dc-s {
+  display: block;
+  margin: 0;
+  font-size: 0.65625rem;
+  line-height: 1.35;
+  /* `--fg-muted` et non `--fg-subtle` : la sous-ligne est la plus petite
+     chose de la carte, et `--fg-subtle` ne garde que 4,6:1 sur `--bg-inset`.
+     `--fg-muted` en donne près de sept dans les deux thèmes. */
+  color: rgb(var(--fg-muted));
+  font-variant-numeric: tabular-nums;
+}
+
+.dc-xseed {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.2rem 0.6rem;
+  margin: 0.4rem 0 0;
+  font-size: 0.6875rem;
+  color: rgb(var(--fg-muted));
+  font-variant-numeric: tabular-nums;
+}
+
+/* ── La barre d'action ────────────────────────────────────────────────────── */
+/* Le CTA prend la largeur sur mobile et se contente de la sienne dès qu'il y
+   a de la place : un bouton de 700 px de large ne se lit pas comme un
+   bouton. */
+/* La rangée : les actions à gauche, le CTA poussé à droite. Elles passent à la
+   ligne avant lui quand la place manque — c'est le CTA qui doit rester entier,
+   pas la rangée de secondaires. */
+@media (min-width: 40rem) {
+  .dc-cta {
+    display: block;
+  }
+}
+
+
+/* ── Le bonus ─────────────────────────────────────────────────────────────── */
+.dc-buff {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.35rem 0.5rem;
+  padding: 0.45rem 0.55rem;
+  /* Le voile chaud est de retour, et cette fois il est mesuré. Ce que la note
+     d'origine avait écarté, c'était un texte de la MÊME famille sur ce voile —
+     `--accent-warm-text` sur un voile d'or tombe à 4,13:1 en clair. Ici les
+     trois textes sont neutres (`--fg-strong`, `--fg-muted`) et la pastille est
+     un aplat, pas un texte : `--fg-default` sur un voile d'or à 10 % donne
+     15,32:1 en sombre et 16,17:1 en clair, `--fg-muted` 6,19:1 et 6,09:1. */
+  background-color: rgb(var(--accent-warm) / 0.1);
+  border: 1px solid rgb(var(--accent-warm) / 0.3);
+  border-left: 3px solid rgb(var(--accent-warm));
+  border-radius: var(--radius-md);
+}
+.dc-buff-badge {
+  display: inline-flex;
+  align-items: center;
+  height: 1.4rem;
+  padding: 0 0.45rem;
+  font-size: var(--label-md, 0.625rem);
+  font-weight: 800;
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  /* La paire prévue pour ça, et la seule qui tienne dans les deux thèmes. */
+  background-color: rgb(var(--accent-warm));
+  color: rgb(var(--accent-warm-fg));
+  border-radius: var(--radius-sm);
+}
+.dc-buff-pair {
+  font-family: var(--font-mono);
+  font-size: 0.71875rem;
+  font-weight: 700;
+  font-variant-numeric: tabular-nums;
+  color: rgb(var(--fg-strong));
+}
+.dc-buff-note {
+  font-size: 0.71875rem;
+  color: rgb(var(--fg-muted));
+}
+.dc-buff-until {
+  font-size: 0.71875rem;
+  color: rgb(var(--fg-muted));
+  font-variant-numeric: tabular-nums;
+}
+
+/* ── Responsive réel : trois paliers, pas un seul point de rupture ───────── */
+
+
+@media (max-width: 767px) {
+  .dc-band {
+    padding: 0.6rem 0.65rem;
+  }
+  .dc-stats {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+  .dc-v {
+    /* Réduit, pas rabaissé : il reste la plus grosse chose de la carte, parce
+       qu'un téléphone est justement l'écran où l'on décide en un coup d'œil. */
+    font-size: 1.05rem;
+  }
+  .dc-spacer {
+    display: none;
+  }
+}
+
+/* Le CTA prend toute la largeur de la carte : la racine de `DownloadCta` est
+   atteinte par ce style scopé, comme pour toutes les racines d'enfants. */
+.dc-band--cta {
+  padding: 0.85rem 0.85rem 0.75rem;
+}
+.dc-band--cta > .dlc {
+  width: 100%;
+  justify-content: center;
+}
+
+/* ── Ce que ça vous coûte ─────────────────────────────────────────────── */
+.dc-cost { display: grid; gap: 0.25rem; }
+.dc-cost-ratio {
+  display: flex;
+  align-items: baseline;
+  flex-wrap: wrap;
+  gap: 0.4rem;
+  margin: 0;
+  font-family: var(--font-mono);
+  font-variant-numeric: tabular-nums;
+}
+.dc-cost-n { font-size: 1.15rem; font-weight: 700; color: rgb(var(--fg-strong)); }
+/* Inchangé : le chiffre d'après en vert — la bonne nouvelle, dite aussi en
+   toutes lettres à côté pour qui ne voit pas la couleur. */
+.dc-cost-n--same { color: rgb(var(--online)); }
+.dc-cost-arrow { align-self: center; color: rgb(var(--fg-subtle)); }
+.dc-cost-tag { font-family: var(--font-sans); font-size: 0.6875rem; font-weight: 600; color: rgb(var(--online)); }
+.dc-cost-note { margin: 0; font-size: 0.6875rem; line-height: 1.45; color: rgb(var(--fg-muted)); }
+
+/* ── La réglette des chiffres ─────────────────────────────────────────── */
+.dc-strip {
+  display: grid;
+  /* Trois cellules côte à côte dans la colonne ; une quatrième (échangés en
+     cross-seed) fait passer à deux par deux plutôt qu'à quatre étroites. */
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 5.5rem), 1fr));
+  margin: 0;
+}
+.dc-cell {
+  --cell-tone: var(--fg-muted);
+  min-width: 0;
+  padding: 0.15rem 0.6rem 0.1rem;
+}
+.dc-cell[data-changed] {
+  animation: dc-flash calc(500ms * var(--motion-scale)) var(--ease-standard) both;
+}
+@keyframes dc-flash {
+  from { background-color: rgb(var(--cell-tone) / 0.16); }
+  to { background-color: transparent; }
+}
+.dcn-enter-active,
+.dcn-leave-active {
+  display: inline-block;
+  transition: opacity var(--dur-3) var(--ease-emphasis), transform var(--dur-3) var(--ease-emphasis);
+}
+.dcn-enter-from { opacity: 0; transform: translateY(0.4em); }
+.dcn-leave-to { opacity: 0; transform: translateY(-0.4em); }
+.dc-cell + .dc-cell {
+  border-left: 1px solid rgb(var(--line-default));
+}
+.dc-cell--seed { --cell-tone: var(--online); }
+.dc-cell--leech { --cell-tone: var(--info); }
+
+@media (prefers-reduced-motion: reduce) {
+  .dc-cell[data-changed] { animation: none; }
+  .dcn-enter-active,
+  .dcn-leave-active { transition: none; }
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/DownloadCta.vue b/apps/web/app/components/torrent/detail/DownloadCta.vue
new file mode 100644
index 00000000..85c2439f
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/DownloadCta.vue
@@ -0,0 +1,351 @@
+<script setup lang="ts">
+/**
+ * Le bouton de téléchargement — l'or du site, en aplat.
+ *
+ * # Pourquoi l'or et non `--accent`
+ *
+ * Il portait `--accent`, qui est achromatique dans les deux thèmes livrés
+ * (blanc sur sombre, quasi noir sur clair) : la seule action pour laquelle la
+ * page existe était la chose la plus grise de la page. Les deux références que
+ * le propriétaire tient pour réussies mettent chacune une couleur saturée sur
+ * ce bouton — vert vif pour l'une, bleu pour l'autre — et c'est ce qui les
+ * fait lire comme des sites plutôt que comme des tableurs.
+ *
+ * `--accent-warm` est la couleur à laquelle ce site se reconnaît, et sa paire
+ * avec `--accent-warm-fg` est celle que le portail de contraste mesure déjà :
+ * **7,77:1 en thème sombre, 5,15:1 en thème clair**. Les deux passent AA, le
+ * sombre passe AAA. `--accent` reste ce qu'il est — le jeton d'accentuation
+ * neutre du reste du site ; c'est cette page qui préfère sa signature.
+ *
+ * # Pourquoi le survol ne change pas le remplissage
+ *
+ * Un voile de 12 % par-dessus l'or l'éclaircit en sombre (l'encre monte à
+ * 8,64:1) mais l'ASSOMBRIT en clair, où `--fg-strong` est noir : l'encre
+ * tombe alors à 4,10:1, sous les 4,5:1 — l'état de survol échouerait dans un
+ * thème sur deux, exactement le défaut que la note de `--danger-fg` décrit
+ * dans `main.css`. Le survol passe donc par un anneau, une ombre et un
+ * soulèvement d'un pixel : trois signaux visibles, zéro couleur non mesurée.
+ *
+ * # Un vrai lien
+ *
+ * `<a href download>`, pas un `<button @click>` qui construirait la même URL
+ * en JavaScript. Un lien se copie, s'ouvre dans un onglet, se voit dans la
+ * barre d'état, marche sans JavaScript et sait déjà ce qu'est une cible
+ * `download`. La version bouton n'apporte rien et perd tout cela.
+ *
+ * # Un seul, à chaque largeur
+ *
+ * Au-dessus de 1280 px, l'exemplaire principal vit dans la barre d'action ;
+ * en dessous, il DISPARAÎT (`display: none`, donc hors de l'ordre de
+ * tabulation) et c'est la barre basse collante qui le porte. Deux exemplaires
+ * simultanés, c'est deux fois « télécharger » dans la liste des liens d'un
+ * lecteur d'écran, et un membre qui ne sait pas lequel des deux est le bon.
+ *
+ * La règle est portée ICI et non par la page : la garantie doit tenir quel que
+ * soit l'endroit où le composant est monté.
+ *
+ * # Pourquoi la sous-ligne n'a pas d'alpha
+ *
+ * `rgb(var(--accent-warm-fg) / 0.75)` sur un aplat d'or tombe sous 4,5:1 :
+ * l'or a précisément une luminance moyenne, donc le défaut n'est plus masqué
+ * comme il l'était sur un accent achromatique — il est certain. La hiérarchie
+ * passe par la taille et la graisse, jamais par la transparence.
+ */
+const props = withDefaults(
+  defineProps<{
+    /** L'infohash. Construit l'URL du `.torrent`. */
+    hash: string;
+    /** Taille du contenu, pour la sous-ligne. */
+    size?: number | null;
+    /** Seeders, pour la sous-ligne. */
+    seeders?: number | null;
+    /** Résumé de qualité déjà composé — « 2160p REMUX ». */
+    quality?: string | null;
+    /** Le torrent est gratuit : la sous-ligne le dit, c'est décisif. */
+    freeleech?: boolean;
+    /**
+     * `primary` dans la barre d'action (caché sous 1280 px), `dock` dans la
+     * barre basse (qui n'existe que sous 1280 px).
+     */
+    variant?: 'primary' | 'dock';
+  }>(),
+  {
+    size: null,
+    seeders: null,
+    quality: null,
+    freeleech: false,
+    variant: 'primary',
+  },
+);
+
+const { t, locale } = useI18n();
+const emit = defineEmits<{ (e: 'taken'): void }>();
+
+const href = computed(() => `/api/torrents/${props.hash}/download`);
+
+/**
+ * La seule récompense animée de la page : au clic, la flèche devient une coche
+ * et un anneau se referme autour du bouton. Rien n'est empêché — le
+ * navigateur télécharge — et la page est prévenue pour relire l'obligation.
+ */
+const taken = ref(false);
+let takenTimer: ReturnType<typeof setTimeout> | null = null;
+function onClick() {
+  taken.value = true;
+  emit('taken');
+  if (takenTimer) clearTimeout(takenTimer);
+  takenTimer = setTimeout(() => (taken.value = false), 1400);
+}
+onBeforeUnmount(() => { if (takenTimer) clearTimeout(takenTimer); });
+
+/**
+ * Ce qu'on annonce sous le libellé : taille, qualité, seeders, gratuité.
+ *
+ * Les parts absentes sont retirées et non rendues vides — une sous-ligne
+ * « · · 47 seeders » sur une release dont la qualité n'a pas été analysée est
+ * pire que pas de sous-ligne du tout.
+ */
+const subParts = computed(() => {
+  const out: string[] = [];
+  if (typeof props.size === 'number' && props.size > 0) out.push(formatSize(props.size));
+  if (props.quality) out.push(props.quality);
+  if (typeof props.seeders === 'number') {
+    out.push(
+      t(
+        'torrents.detail.cta.seeders',
+        { n: props.seeders.toLocaleString(locale.value) },
+        props.seeders,
+      ),
+    );
+  }
+  if (props.freeleech) out.push(t('torrents.detail.cta.free'));
+  return out;
+});
+/*
+ * « Le CTA principal est-il à l'écran ? »
+ *
+ * La barre basse faisait doublon : elle apparaissait sous 1280 px QUOI QU'IL
+ * ARRIVE, y compris quand le bouton principal était juste au-dessus, visible.
+ * Deux fois la même action à trente centimètres l'une de l'autre.
+ *
+ * Un `IntersectionObserver` sur l'exemplaire primaire répond à la seule
+ * question qui vaille, et la barre s'y abonne. L'état part à `true` : au rendu
+ * serveur et jusqu'au montage, on suppose le bouton visible, donc la barre ne
+ * se rend pas — c'est l'ordre qui évite qu'elle apparaisse puis disparaisse au
+ * premier chargement.
+ */
+const onScreen = useState('torrent-cta-onscreen', () => true);
+const root = ref<HTMLAnchorElement | null>(null);
+
+onMounted(() => {
+  if (props.variant !== 'primary' || !root.value) return;
+  // `IntersectionObserver` manque à quelques navigateurs anciens ; sans lui la
+  // barre reste simplement cachée, ce qui est l'état sûr — le bouton, lui, est
+  // toujours là.
+  if (typeof IntersectionObserver === 'undefined') return;
+  const io = new IntersectionObserver(
+    ([entry]) => {
+      onScreen.value = !!entry?.isIntersecting;
+    },
+    // La barre doit apparaître quand le bouton sort VRAIMENT, pas quand il
+    // effleure le bord.
+    { threshold: 0.1 },
+  );
+  io.observe(root.value);
+  onBeforeUnmount(() => io.disconnect());
+});
+
+// Le composant est démonté avec la page ; l'état est partagé, donc il faut le
+// rendre à sa valeur de repos, sinon la fiche suivante s'ouvre avec la barre
+// déjà affichée.
+onBeforeUnmount(() => {
+  if (props.variant === 'primary') onScreen.value = true;
+});
+</script>
+
+<template>
+  <a
+    ref="root"
+    :href="href"
+    download
+    class="dlc"
+    :class="[`dlc--${variant}`, { 'dlc--taken': taken }]"
+    @click="onClick"
+  >
+    <Icon :name="taken ? 'ph:check-bold' : 'ph:download-simple-bold'" class="dlc-icon" aria-hidden="true" />
+    <span class="dlc-text">
+      <span class="dlc-label">{{ $t('torrents.detail.cta.download') }}</span>
+      <span v-if="variant === 'primary' && subParts.length" class="dlc-sub">{{
+        subParts.join(' · ')
+      }}</span>
+    </span>
+  </a>
+</template>
+
+<style scoped>
+.dlc {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.6rem;
+  text-decoration: none;
+  background-color: rgb(var(--accent-warm));
+  color: rgb(var(--accent-warm-fg));
+  border: 1px solid rgb(var(--accent-warm));
+  border-radius: var(--radius-lg);
+  transition:
+    box-shadow var(--dur-3) var(--ease-standard),
+    transform var(--dur-2) var(--ease-emphasis);
+}
+/* L'or ne bouge pas, son entourage bouge — voir l'en-tête : un voile sur ce
+   remplissage échoue au contraste dans un thème sur deux. */
+.dlc:hover {
+  transform: translateY(-1px);
+  box-shadow:
+    0 0 0 3px rgb(var(--accent-warm) / 0.28),
+    0 6px 16px -8px rgb(var(--shadow-color) / calc(0.7 * var(--shadow-strength)));
+}
+.dlc:active {
+  transform: translateY(1px);
+  box-shadow: 0 0 0 2px rgb(var(--accent-warm) / 0.35);
+}
+/* Un lien reste un lien : l'anneau de focus du site, jamais remplacé par le
+   traitement de survol. */
+.dlc:focus-visible {
+  outline: 2px solid rgb(var(--focus-ring));
+  outline-offset: 3px;
+}
+@media (prefers-reduced-motion: reduce) {
+  .dlc:hover,
+  .dlc:active {
+    transform: none;
+  }
+}
+
+.dlc-icon {
+  flex: none;
+  font-size: 1.125rem;
+}
+/* Le moment : la coche surgit, l'anneau se referme. Toutes les durées passent
+   par `--motion-scale`, donc rien ne bouge sous « réduire les animations ». */
+.dlc--taken .dlc-icon {
+  animation: dlc-pop var(--dur-3) var(--ease-emphasis) both;
+}
+@keyframes dlc-pop {
+  from { transform: scale(0.5); opacity: 0; }
+}
+.dlc::after {
+  content: '';
+  position: absolute;
+  inset: -1px;
+  border-radius: inherit;
+  pointer-events: none;
+  opacity: 0;
+}
+.dlc--taken::after {
+  animation: dlc-ring var(--dur-slow) var(--ease-standard) both;
+}
+@keyframes dlc-ring {
+  from { opacity: 1; box-shadow: 0 0 0 0 rgb(var(--accent-warm) / 0.6); }
+  to { opacity: 0; box-shadow: 0 0 0 14px rgb(var(--accent-warm) / 0); }
+}
+.dlc-text {
+  display: flex;
+  flex-direction: column;
+  gap: 0.05rem;
+  min-width: 0;
+}
+
+/* ── L'exemplaire principal : 52 px de haut contre des fantômes de 34 ────── */
+.dlc--primary {
+  min-height: 3.25rem;
+  padding: 0 1.4rem;
+  flex: 0 1 auto;
+  box-shadow: 0 1px 0 rgb(var(--shadow-color) / 0.25);
+}
+.dlc--primary .dlc-icon {
+  /* La flèche descend d'un cheveu au survol : le geste que le bouton décrit.
+     Une micro-interaction qui dit quelque chose, pas un rebond décoratif. */
+  transition: transform var(--dur-2) var(--ease-emphasis);
+}
+.dlc--primary:hover .dlc-icon {
+  transform: translateY(2px);
+}
+@media (prefers-reduced-motion: reduce) {
+  .dlc--primary:hover .dlc-icon {
+    transform: none;
+  }
+}
+.dlc--primary .dlc-label {
+  /* `rem`, jamais `px` : `--ui-scale` n'agit que sur `html { font-size }`. */
+  font-size: 0.9375rem;
+  font-weight: 800;
+  letter-spacing: calc(-0.005em * var(--tracking-scale));
+  line-height: 1.2;
+}
+.dlc--primary .dlc-sub {
+  /* Pleine opacité — voir l'en-tête : un alpha sur cette encre casse le
+     contraste, l'or ayant précisément une luminance moyenne. */
+  color: rgb(var(--accent-warm-fg));
+  font-size: 0.6875rem;
+  font-weight: 600;
+  line-height: 1.3;
+  font-variant-numeric: tabular-nums;
+  letter-spacing: calc(0.01em * var(--tracking-scale));
+}
+
+/* Le CTA primaire reste À TOUTES LES LARGEURS.
+ *
+ * Il disparaissait sous 1280 px pour laisser la barre basse porter le
+ * téléchargement, avec l'argument « un seul contrôle focalisable ». La règle
+ * tenait, son prix ne se voyait pas : la barre basse est le DERNIER enfant du
+ * document (elle doit l'être, `position: sticky` colle par le bas), donc son
+ * bouton était mesuré comme le **34ᵉ et dernier arrêt de tabulation** de la
+ * page. Quelqu'un au clavier traversait trente-trois contrôles — copier,
+ * étiquettes, lignes de versions, champ de commentaire, formulaires
+ * d'exploitant — avant d'atteindre ce pour quoi la page existe.
+ *
+ * Le CTA de la carte de décision est au 8ᵉ rang. Il redevient donc le contrôle
+ * réel, et celui de la barre basse un doublon POUR LA SOURIS : `aria-hidden` et
+ * `tabindex="-1"` le sortent de l'ordre de tabulation et de l'arbre
+ * d'accessibilité, ce qui est exactement la dérogation « équivalent » de
+ * WCAG 2.5.8 — une cible qui a son équivalent ailleurs sur la page.
+ *
+ * Ce que ça coûte : sous 1280 px, deux boutons visibles au lieu d'un. C'est le
+ * prix, et il est plus petit que celui d'un raccourci clavier de trente-trois
+ * arrêts. */
+
+/* ── L'exemplaire de la barre basse : une ligne, pas de sous-ligne ───────── */
+.dlc--dock {
+  flex: none;
+  margin-left: auto;
+  padding: 0.6875rem 1.125rem;
+  gap: 0.45rem;
+}
+.dlc--dock .dlc-label {
+  font-size: 0.875rem;
+  font-weight: 700;
+  line-height: 1.2;
+  white-space: nowrap;
+}
+
+@media (max-width: 767px) {
+  .dlc--primary {
+    /* Sur téléphone il n'existe pas, mais la règle reste vraie si un appelant
+       futur le remonte : pleine largeur plutôt qu'un bouton flottant. */
+    width: 100%;
+    justify-content: center;
+    padding: 0 0.75rem;
+  }
+  .dlc--dock {
+    width: 100%;
+    margin-left: 0;
+    justify-content: center;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .dlc--taken .dlc-icon,
+  .dlc--taken::after { animation: none; }
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/ExpandAllToggle.vue b/apps/web/app/components/torrent/detail/ExpandAllToggle.vue
new file mode 100644
index 00000000..9761ae24
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/ExpandAllToggle.vue
@@ -0,0 +1,108 @@
+<script setup lang="ts">
+/**
+ * « Tout afficher » — la réponse au `Ctrl+F`.
+ *
+ * Les sections repliées coûtent 60 px au lieu de ~2000, et c'est la raison
+ * d'être du bas de page. Mais ce qui est en `display: none` est introuvable par
+ * la recherche du navigateur, qu'on ne peut pas intercepter. Cette case déplie
+ * tout d'un coup : le membre qui cherche une piste de sous-titres par `Ctrl+F`
+ * la coche une fois et la fiche entière redevient cherchable.
+ *
+ * La maquette lui donnait une case de 14 × 14 px. Ici la cible est le
+ * `<label>` entier, 2rem de haut (32 px au réglage d'échelle par défaut) :
+ * au-dessus des 24 px de la 2.5.8, alors qu'une case de 14 px est
+ * précisément ce qu'on n'atteint pas au doigt.
+ */
+const expandAll = useExpandAll();
+const fid = useFieldIds();
+</script>
+
+<template>
+  <div class="xall">
+    <!-- `<label for>` apparié plutôt qu'un `aria-label` : le libellé est
+         visible, et un clic dessus doit cocher la case — c'est la moitié de la
+         cible tactile. -->
+    <!-- `title` : « (Ctrl+F) » se lisait comme la touche qui coche la case —
+         d'autant plus depuis que D et F sont annoncés en <kbd> plus bas. La
+         mention visible dit maintenant POUR quoi, et l'infobulle le reste. -->
+    <label class="xall-label" :for="fid('expand-all')" :title="$t('torrents.detail.expandAll.title')">
+      <input
+        :id="fid('expand-all')"
+        v-model="expandAll"
+        type="checkbox"
+        class="xall-box"
+        :aria-describedby="expandAll ? fid('expand-all-note') : undefined"
+      >
+      <span class="xall-text">
+        {{ $t('torrents.detail.expandAll.label') }}
+        <span class="xall-kbd" aria-hidden="true">{{ $t('torrents.detail.expandAll.shortcut') }}</span>
+      </span>
+    </label>
+    <!-- La confirmation, pour qui ne voit pas le résultat.
+         Elle occupait une ligne sous la case ; depuis que la commande vit dans
+         la barre du haut, à côté du lien de retour, cette ligne coûterait à
+         elle seule plus de hauteur que le contrôle. Or ce qu'elle annonce —
+         « toutes les sections sont ouvertes » — se CONSTATE d'un coup d'œil
+         quand on voit la page. Elle reste donc dans le document, rattachée à
+         la case par `aria-describedby`, pour qui n'a pas ce coup d'œil. -->
+    <p v-if="expandAll" :id="fid('expand-all-note')" class="sr-only">
+      {{ $t('torrents.detail.expandAll.note') }}
+    </p>
+  </div>
+</template>
+
+<style scoped>
+.xall {
+  display: flex;
+}
+
+/* La cible entière, pas seulement le carré, et le libellé dedans.
+   2 rem au lieu de 2,75 : dans la barre du haut elle voisine un lien de
+   24 px, et une pilule de 44 y pesait plus que la page. 32 px restent
+   au-dessus des 24 de WCAG 2.5.8. */
+.xall-label {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+  min-height: 2rem;
+  padding: 0 0.65rem 0 0.45rem;
+  border: 1px solid rgb(var(--line-default));
+  border-radius: var(--radius-pill);
+  /* Translucide et floutée : elle flotte sur le bandeau de la fiche, à côté du
+     lien de retour qui porte la même recette. */
+  background: rgb(var(--bg-elevated) / 0.82);
+  backdrop-filter: blur(8px);
+  cursor: pointer;
+  transition:
+    border-color var(--dur-2) ease,
+    background-color var(--dur-2) ease;
+}
+.xall-label:hover {
+  border-color: rgb(var(--fg-default) / 0.3);
+  background: rgb(var(--bg-hover));
+}
+
+.xall-box {
+  flex: none;
+  width: 1.1rem;
+  height: 1.1rem;
+  margin: 0;
+  accent-color: rgb(var(--accent-warm));
+  cursor: pointer;
+}
+
+.xall-text {
+  display: inline-flex;
+  align-items: baseline;
+  gap: 0.4rem;
+  font-size: 0.8125rem;
+  font-weight: 600;
+  color: rgb(var(--fg-default));
+}
+.xall-kbd {
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  font-weight: 500;
+  color: rgb(var(--fg-muted));
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/FederationSwarmToggle.vue b/apps/web/app/components/torrent/detail/FederationSwarmToggle.vue
new file mode 100644
index 00000000..801a3c3b
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/FederationSwarmToggle.vue
@@ -0,0 +1,111 @@
+<script setup lang="ts">
+/**
+ * Partager le swarm de CE torrent avec les instances partenaires, ou non.
+ *
+ * # Ce que le bouton engage
+ *
+ * Activé, les pairs de ce torrent peuvent être annoncés aux partenaires avec
+ * qui l'instance a un lien de swarm — et mélangés depuis eux. Cela partage des
+ * IP de pairs : le réglage est désactivé par défaut et se prend torrent par
+ * torrent, jamais globalement.
+ *
+ * # Deux gardes, pas une
+ *
+ * L'appelant ne monte ce composant que si l'exploitant peut éditer la release
+ * ET que l'instance est fédérée. Sur une instance non fédérée il n'y a
+ * personne AVEC qui partager, et proposer l'interrupteur n'inviterait qu'une
+ * question : pourquoi ne fait-il rien ?
+ *
+ * # L'état local
+ *
+ * `enabled` amorce la référence interne et ne la pilote pas : en cas d'échec du
+ * PUT on garde l'état visuel précédent plutôt que d'annoncer un changement qui
+ * n'a pas eu lieu.
+ */
+const props = withDefaults(
+  defineProps<{
+    /** Le hash, pour `PUT /api/torrents/:hash/federate-swarm`. */
+    hash: string;
+    /** L'état stocké sur la ligne, qui amorce l'interrupteur. */
+    enabled?: boolean;
+  }>(),
+  { enabled: false },
+);
+
+const on = ref(false);
+const busy = ref(false);
+
+watch(
+  () => props.enabled,
+  (v) => {
+    on.value = !!v;
+  },
+  { immediate: true },
+);
+
+async function toggle() {
+  const next = !on.value;
+  if (!props.hash) return;
+  busy.value = true;
+  try {
+    await $fetch(`/api/torrents/${props.hash}/federate-swarm`, {
+      method: 'PUT',
+      body: { enabled: next },
+    });
+    on.value = next;
+  } catch {
+    /* on garde l'état visuel précédent */
+  } finally {
+    busy.value = false;
+  }
+}
+</script>
+
+<template>
+  <section class="section">
+    <SectionHead :title="$t('torrents.detail.fedSwarm.title')" icon="ph:broadcast" />
+
+    <div class="fed-swarm">
+      <p class="fed-swarm__desc">{{ $t('torrents.detail.fedSwarm.desc') }}</p>
+      <button type="button" class="btn btn-secondary" :disabled="busy" @click="toggle">
+        <Icon :name="on ? 'ph:broadcast-bold' : 'ph:broadcast'" />
+        {{ on ? $t('torrents.detail.fedSwarm.on') : $t('torrents.detail.fedSwarm.off') }}
+      </button>
+    </div>
+  </section>
+</template>
+
+<style scoped>
+/* Copie locale : `.section` appartenait à la page, pas au CSS global. */
+.section {
+  /* Même bloc que dans `AdminSwarmTable.vue`, `SupersedeForm.vue` et
+     `FederationSwarmToggle.vue` : quatre copies d'un motif que la page
+     possédait et que `main.css` ne connaît pas. Le rail bleu est la marque de
+     la famille « exploitation » ; il est ajouté aux quatre à l'identique, et
+     l'en-tête de `AdminSwarmTable.vue` porte la mesure. */
+  --section-tone: var(--chart-1);
+  padding: 1rem 1.1rem;
+  border: 1px solid rgb(var(--line-default));
+  border-left: 3px solid rgb(var(--chart-1) / 0.55);
+  border-radius: var(--radius-lg);
+  background: rgb(var(--bg-surface));
+}
+
+/* Ces trois règles étaient des attributs `style` en ligne sur la page. Sorties
+   ici, elles sont surchargeables et lisibles — et la taille de police repasse
+   par une feuille, donc par `--ui-scale`. */
+.fed-swarm {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  flex-wrap: wrap;
+  gap: 1rem;
+}
+.fed-swarm__desc {
+  max-width: 62ch;
+  margin: 0;
+  font-size: 0.8125rem;
+  line-height: 1.55;
+  color: rgb(var(--fg-muted));
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/IdentityCard.vue b/apps/web/app/components/torrent/detail/IdentityCard.vue
new file mode 100644
index 00000000..4dd5c439
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/IdentityCard.vue
@@ -0,0 +1,1221 @@
+<script setup lang="ts">
+import type { MediaMetadata } from '@trackarr/shared/media';
+
+/**
+ * Qu'est-ce que c'est, et de quelle release parle-t-on.
+ *
+ * # L'affiche est un cas d'absence, pas un cas de présence
+ *
+ * `posterUrl` arrive à `null` en routine : l'exploitant n'a pas de clé TMDb,
+ * le fournisseur ne connaît pas l'œuvre, ou la catégorie n'a pas de
+ * fournisseur du tout. Un `<img>` sans `src` laisse un rectangle cassé, et un
+ * `v-if` sans repli laisse la grille se refermer et le titre glisser de 4,5 rem
+ * vers la gauche — deux pages du même site qui ne se ressemblent pas. Le
+ * substitut est donc un OBJET dessiné, à la même taille, qui dit ce qui manque.
+ *
+ * # Le nom de release est un objet de première classe
+ *
+ * Pas une ligne de sous-titre : un bloc mono, sélectionnable d'un seul clic
+ * (`user-select: all`), copiable d'un bouton, et coupé aux séparateurs.
+ * `overflow-wrap: anywhere` seul coupe au milieu d'un mot — `TSUNDE` / `RE` —
+ * ce qui rend un nom illisible exactement là où il faut le comparer à un
+ * autre. Un `<wbr>` après chaque `.`, `_` et `-` donne au navigateur les
+ * points de coupe légitimes, et il n'en cherche pas d'autres.
+ *
+ * Les segments sont rendus par `v-for`, pas par `v-html` : un nom de release
+ * est une chaîne fournie par un membre, et la seule raison d'appeler
+ * `v-html` ici serait d'y injecter les `<wbr>` — c'est-à-dire de reprendre à
+ * la main un échappement que Vue fait déjà correctement.
+ *
+ * # L'infohash est la SECONDE désignation, pas une donnée technique de plus
+ *
+ * Il est posé sous le nom de release, dans le même bloc et avec le même
+ * bouton de copie, parce que les deux désignent la même release — l'un pour
+ * un humain, l'autre pour un client. Les séparer (le nom ici, le hash dans un
+ * ruban de métadonnées trois écrans plus bas) obligeait à chercher deux fois
+ * pour la même question, « de quelle release parle-t-on ».
+ *
+ * # Les fiches publiques appartiennent à l'ŒUVRE
+ *
+ * IMDb, TMDb, TVDB, IGDB, Open Library sont au même rang que la note, les
+ * genres et le réalisateur : des faits sur l'œuvre, qu'on consulte en
+ * regardant l'affiche et le titre. Ils sont donc juste sous la ligne de méta,
+ * et pas avec l'uploadeur ou les étiquettes, qui parlent de la PUBLICATION.
+ */
+const props = withDefaults(
+  defineProps<{
+    /** Le nom de release. Toujours présent, c'est l'identité du torrent. */
+    releaseName: string;
+    /** Les métadonnées de l'œuvre. `null` est le cas courant, pas l'exception. */
+    media?: MediaMetadata | null;
+    /**
+     * Le titre à afficher quand aucun fournisseur n'a répondu. La page y met
+     * en général le titre nettoyé du torrent ; sans rien, le nom de release
+     * devient lui-même le titre de la page.
+     */
+    fallbackTitle?: string | null;
+    /** `h1` sur la page de détail, `h2` partout ailleurs. */
+    titleLevel?: 'h1' | 'h2';
+    /**
+     * La recherche de métadonnées est encore en vol.
+     *
+     * Sans ce drapeau, `media: null` couvre DEUX états très différents — « il
+     * n'y a pas d'affiche » et « on ne sait pas encore » — et la carte
+     * affirmait le premier dans les deux cas. La recherche part côté client
+     * (elle dépend du torrent, qui n'est pas encore résolu quand le composable
+     * la déclare), donc le rendu serveur tombait systématiquement sur
+     * « Sans affiche » avant de le démentir une demi-seconde plus tard.
+     */
+    mediaPending?: boolean;
+    /**
+     * L'infohash de la release. 40 caractères en SHA-1, 64 en BEP 52.
+     *
+     * Optionnel parce que la carte sert aussi de bloc d'identité pour une
+     * œuvre sans release précise ; absent, le bloc de hash ne se rend pas.
+     */
+    infoHash?: string | null;
+    /** L'identifiant IMDb tel qu'il est stocké — préfixe `tt` compris. */
+    imdbId?: string | null;
+    /**
+     * Le lien TMDb DÉJÀ dérivé, jamais l'identifiant brut.
+     *
+     * `normalizeTmdbId` préserve délibérément le préfixe quand l'uploadeur
+     * colle une URL : la colonne porte tantôt `693134`, tantôt `tv/34114`.
+     * Une URL construite ici à partir de la valeur brute casserait sur la
+     * seconde forme, et c'est `useTorrentDetail` qui résout déjà les deux.
+     */
+    tmdbLink?: { href: string; label: string } | null;
+    tvdbId?: string | null;
+    igdbId?: string | null;
+    openlibraryId?: string | null;
+    /**
+     * Le fil d'orientation au-dessus du titre : catégorie › œuvre › unité
+     * (« Séries / Frieren / Saison 01 · Épisode 09 »). L'épisode n'apparaissait
+     * que dans la barre d'unité du tableau des versions, 700 px plus bas ; on
+     * ouvrait la fiche sans savoir DE QUOI on regardait la release. Chaque
+     * maillon peut porter un lien — le catalogue filtré, la page du groupe.
+     */
+    crumbs?: ReadonlyArray<{ label: string; to?: string | null; minor?: boolean }> | null;
+    /**
+     * Propose « Mauvaise fiche ? » à côté des fiches publiques : la page émet
+     * `report-metadata` et ouvre son signalement avec le motif prérempli.
+     */
+    canReport?: boolean;
+  }>(),
+  {
+    media: null,
+    fallbackTitle: null,
+    titleLevel: 'h1',
+    mediaPending: false,
+    infoHash: null,
+    imdbId: null,
+    tmdbLink: null,
+    tvdbId: null,
+    igdbId: null,
+    openlibraryId: null,
+    crumbs: null,
+    canReport: false,
+  },
+);
+
+const emit = defineEmits<{ (e: 'report-metadata'): void; (e: 'tint', rgb: string | null): void }>();
+
+const { t, locale } = useI18n();
+
+const workTitle = computed(() => props.media?.title || props.fallbackTitle || null);
+const year = computed(() => props.media?.year ?? null);
+
+/** Le titre d'origine, seulement quand il APPORTE quelque chose. */
+const originalTitle = computed(() => {
+  const orig = props.media?.originalTitle;
+  if (!orig || !workTitle.value) return null;
+  return orig === workTitle.value ? null : orig;
+});
+
+const posterUrl = computed(() => props.media?.posterUrl || null);
+
+/**
+ * Rien à montrer de l'œuvre : ni affiche, ni titre, et pas de recherche en
+ * cours. C'est le cas COURANT — musique, jeux, livres, tout ce que TMDb ne
+ * connaît pas — et le héros le traitait comme une exception : une tuile
+ * « Sans affiche » de 192 × 288 px, un bandeau uni de 192 px, et le nom de
+ * release en titre d'affiche sur deux lignes, répété mot pour mot dans la
+ * bande d'identité 40 px plus bas. Mesuré : ~480 px de héros pour zéro
+ * information. Ici, la tuile disparaît, le bandeau se réduit à une entrée de
+ * page, et le titre est celui que la page a su extraire du nom — ou rien.
+ */
+const plain = computed(
+  () => !posterUrl.value && !props.mediaPending && !props.media?.title,
+);
+
+/**
+ * Le décor de l'œuvre — la seule donnée riche que la charge TMDb contenait et
+ * que personne ne regardait.
+ *
+ * `backdropUrl` arrive dans `MediaMetadata` depuis toujours et n'était rendu
+ * nulle part. Il devient un lavis DERRIÈRE l'affiche, masqué avant d'atteindre
+ * le texte : la carte gagne une atmosphère propre à la release au lieu d'un
+ * aplat gris de plus, sans qu'aucune lettre ne change de fond.
+ */
+const backdropUrl = computed(() => props.media?.backdropUrl || null);
+/** `url("…")` avec les guillemets et les barres obliques échappés : une URL
+ *  n'écrit jamais elle-même la fin de sa fonction CSS. */
+const cssUrl = (u: string) => `url("${u.replace(/[\\"]/g, '\\$&').replace(/[\n\r]/g, '')}")`;
+
+/**
+ * Le décor glisse un peu moins vite que la page.
+ *
+ * C'est le seul mouvement de la fiche, et le seul qui ait un sens ici : le
+ * voile suggère une profondeur, le glissement la donne. Quatre garde-fous.
+ * `prefers-reduced-motion` ne déplace rien. Sous 48 rem non plus : le bandeau
+ * y est presque aussi haut que l'image, il n'y a rien à faire glisser sans
+ * zoomer dedans. Rien ne se recalcule une fois le bandeau sorti de l'écran.
+ * Et le glissement est borné à la marge d'image réservée au-dessus du cadre
+ * (24 % de sa hauteur, voir `::before`) pour qu'aucun bord ne se découvre,
+ * quelle que soit la vitesse.
+ *
+ * Pourquoi 24 % et pas plus : c'est ce qu'un décor 16:9 a au-dessus du cadrage
+ * `center 28%` sur un bandeau de rapport 3,33 (30 vw de haut). Une marge plus
+ * grande obligeait à cadrer plus bas au repos — la première version prenait
+ * 35 %, et la tête de Subaru sortait du cadre sur Re:ZERO.
+ *
+ * Un `transform` sur une couche à part, posé une fois par image : le voile et
+ * le bord haut ne bougent pas, la page ne recalcule aucune mise en page.
+ */
+/**
+ * La couleur de l'œuvre.
+ *
+ * L'affiche est échantillonnée sur une toile de 12 × 18 : moyenne des pixels
+ * pondérée par leur saturation, sans les noirs ni les blancs, puis ramenée à
+ * une saturation et une luminosité bornées — une TEINTE, jamais une
+ * luminosité, pour qu'elle se mélange pareil sur les deux thèmes. Frieren tire
+ * vers le vert, Dune vers l'orangé. Elle ne touche que des surfaces
+ * décoratives : le haut du voile, le cadre de la carte de décision.
+ *
+ * Les CDN d'affiches n'envoient pas d'en-tête CORS (mesuré sur TMDB : l'image
+ * en mode `anonymous` ne charge pas, et sans lui la toile est souillée). Le
+ * pixel passe donc par `/_media/sample`, une route de ce serveur qui ne relaie
+ * que des images, depuis trois hôtes connus, vers nos propres pages.
+ */
+const tint = ref<string | null>(null);
+function hsl(r: number, g: number, b: number): [number, number, number] {
+  r /= 255; g /= 255; b /= 255;
+  const mx = Math.max(r, g, b), mn = Math.min(r, g, b), l = (mx + mn) / 2;
+  if (mx === mn) return [0, 0, l];
+  const d = mx - mn;
+  const s = d / (1 - Math.abs(2 * l - 1));
+  let h = mx === r ? (g - b) / d + (g < b ? 6 : 0) : mx === g ? (b - r) / d + 2 : (r - g) / d + 4;
+  return [h / 6, s, l];
+}
+function rgbOf(h: number, s: number, l: number): [number, number, number] {
+  const f = (n: number) => {
+    const k = (n + h * 12) % 12;
+    const a = s * Math.min(l, 1 - l);
+    return Math.round(255 * (l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1))));
+  };
+  return [f(0), f(8), f(4)];
+}
+let alive = true;
+onBeforeUnmount(() => { alive = false; });
+function sampleTint(url: string) {
+  const img = new Image();
+  img.decoding = 'async';
+  img.onload = () => {
+    // Un composant démonté, ou une affiche remplacée pendant le chargement :
+    // l'échantillon ne s'applique pas.
+    if (!alive || posterUrl.value !== url) return;
+    try {
+      const c = document.createElement('canvas');
+      c.width = 12; c.height = 18;
+      const ctx = c.getContext('2d', { willReadFrequently: true });
+      if (!ctx) return;
+      ctx.drawImage(img, 0, 0, 12, 18);
+      const d = ctx.getImageData(0, 0, 12, 18).data;
+      let r = 0, g = 0, b = 0, w = 0;
+      for (let i = 0; i < d.length; i += 4) {
+        const [, s, l] = hsl(d[i]!, d[i + 1]!, d[i + 2]!);
+        if (l < 0.12 || l > 0.9) continue;
+        const wt = s * s;
+        r += d[i]! * wt; g += d[i + 1]! * wt; b += d[i + 2]! * wt; w += wt;
+      }
+      if (w < 0.5) return;
+      const [h, s] = hsl(r / w, g / w, b / w);
+      const [R, G, B] = rgbOf(h, Math.min(0.7, Math.max(0.45, s)), 0.5);
+      tint.value = `${R} ${G} ${B}`;
+      emit('tint', tint.value);
+    } catch {
+      /* toile souillée ou décodage refusé : la fiche reste sans teinte */
+    }
+  };
+  img.src = `/_media/sample?src=${encodeURIComponent(url)}`;
+}
+onMounted(() => {
+  watch(posterUrl, (u) => {
+    tint.value = null;
+    emit('tint', null);
+    if (u) sampleTint(u);
+  }, { immediate: true });
+});
+
+const band = ref<HTMLElement | null>(null);
+let stopDrift: (() => void) | null = null;
+onMounted(() => {
+  const el = band.value;
+  if (!el) return;
+  // Lus à chaque image, pas une fois au montage : une fenêtre qu'on élargit
+  // après le chargement gagne le glissement, une qu'on rétrécit le perd — et le
+  // membre qui active la réduction des animations en cours de route est servi.
+  const wide = window.matchMedia('(min-width: 48rem)');
+  const reduce = window.matchMedia('(prefers-reduced-motion: reduce)');
+  let frame = 0;
+  const tick = () => {
+    frame = 0;
+    if (!backdropUrl.value) return;
+    if (!wide.matches || reduce.matches) {
+      el.style.removeProperty('--idc-drift');
+      return;
+    }
+    const h = el.offsetHeight;
+    const y = window.scrollY;
+    if (y > h * 1.2) return;
+    el.style.setProperty('--idc-drift', `${Math.min(y * 0.3, h * 0.24).toFixed(1)}px`);
+  };
+  const onScroll = () => {
+    if (!frame) frame = requestAnimationFrame(tick);
+  };
+  window.addEventListener('scroll', onScroll, { passive: true });
+  tick();
+  stopDrift = () => {
+    window.removeEventListener('scroll', onScroll);
+    if (frame) cancelAnimationFrame(frame);
+  };
+});
+onBeforeUnmount(() => stopDrift?.());
+
+/**
+ * Le synopsis, borné à deux lignes par la feuille de style.
+ *
+ * Il était dans la charge depuis le début et n'était rendu nulle part. Deux
+ * lignes suffisent à situer une œuvre qu'on ne connaît pas ; au-delà, c'est
+ * la fiche TMDb qui fait ce travail, et elle est à un clic dans les pastilles
+ * juste en dessous.
+ */
+const overview = computed(() => {
+  const o = props.media?.overview?.trim();
+  return o && o.length > 0 ? o : null;
+});
+
+/**
+ * Les fiches publiques de l'œuvre, avec leur lien quand il en existe un.
+ *
+ * # Pourquoi chaque forme est testée avant de devenir une URL
+ *
+ * Un enregistrement antérieur aux normaliseurs peut porter n'importe quoi
+ * dans ces colonnes, et concaténer ce n'importe quoi dans un `href` fabrique
+ * au mieux un lien mort. Une forme inattendue laisse donc la pastille SANS
+ * lien : l'identifiant reste affiché, parce que le rattachement est en
+ * lui-même une information, il n'est simplement pas cliquable.
+ *
+ * # IGDB n'a AUCUN lien dérivable de ce qu'on stocke
+ *
+ * `igdb_id` est numérique (schéma, `torrents.igdb_id`) et les URLs d'igdb.com
+ * ne portent que le slug — `normalizeIgdbId` le dit noir sur blanc : « IGDB
+ * URLs always carry the slug, never the numeric id ». Il n'existe pas de
+ * déréférenceur public par identifiant. Le slug n'apparaît que dans la
+ * réponse du fournisseur, d'où `media.url` comme seule source du lien, et
+ * une pastille sans lien quand la recherche n'a rien rapporté.
+ */
+const mediaLinks = computed(() => {
+  const out: Array<{
+    id: string;
+    provider: string;
+    value: string;
+    href: string | null;
+  }> = [];
+
+  const imdb = props.imdbId?.trim();
+  if (imdb) {
+    out.push({
+      id: 'imdb',
+      provider: 'IMDb',
+      value: imdb,
+      href: /^tt\d+$/i.test(imdb) ? `https://www.imdb.com/title/${imdb}/` : null,
+    });
+  }
+
+  if (props.tmdbLink) {
+    out.push({
+      id: 'tmdb',
+      provider: 'TMDb',
+      value: props.tmdbLink.label,
+      href: props.tmdbLink.href,
+    });
+  }
+
+  const tvdb = props.tvdbId?.trim();
+  if (tvdb) {
+    out.push({
+      id: 'tvdb',
+      provider: 'TVDB',
+      value: tvdb,
+      href: /^\d+$/.test(tvdb)
+        ? `https://thetvdb.com/dereferrer/series/${tvdb}`
+        : null,
+    });
+  }
+
+  const igdb = props.igdbId?.trim();
+  if (igdb) {
+    out.push({
+      id: 'igdb',
+      provider: 'IGDB',
+      value: igdb,
+      href: props.media?.source === 'igdb' ? props.media.url || null : null,
+    });
+  }
+
+  const ol = props.openlibraryId?.trim();
+  if (ol) {
+    // La colonne accepte trois formes (schéma) : un work id, un ISBN-13 ou
+    // un ISBN-10 — et Open Library sert les deux espaces de noms sous des
+    // chemins différents.
+    let href: string | null = null;
+    if (/^OL\d+W$/i.test(ol)) href = `https://openlibrary.org/works/${ol}`;
+    else if (/^\d{10}$|^\d{13}$/.test(ol)) href = `https://openlibrary.org/isbn/${ol}`;
+    out.push({ id: 'openlibrary', provider: 'Open Library', value: ol, href });
+  }
+
+  return out;
+});
+
+/**
+ * L'élément qui porte le nom de release.
+ *
+ * Sans titre d'œuvre, le nom de release EST le titre de la page : il prend le
+ * niveau de titre plutôt que de laisser la page sans `<h1>`. Avec un titre
+ * d'œuvre, c'est un simple bloc — deux titres de même niveau sur une page en
+ * font une page à deux sujets.
+ */
+const nameHost = computed(() => (workTitle.value ? 'div' : props.titleLevel));
+
+/**
+ * Le nom découpé aux séparateurs, séparateur inclus dans le segment qui le
+ * précède.
+ *
+ * Le `<wbr>` doit venir APRÈS le point, sinon la coupe met le point en tête de
+ * la ligne suivante — `.Atmos` — et un nom de release ne se lit plus.
+ */
+const nameChunks = computed(() => props.releaseName.split(/(?<=[._-])/));
+
+const meta = computed(() => {
+  const m = props.media;
+  if (!m) return [];
+  const out: Array<{ id: string; text: string }> = [];
+  if (m.voteCount) {
+    // `{ n }` nommé et non l'argument positionnel : c'est la forme que le
+    // reste du dépôt utilise (`nfoMeta.lines`), et la seule qui interpole
+    // aussi le nombre dans le message.
+    out.push({
+      id: 'votes',
+      text: t('torrents.detail.identity.votes', { n: m.voteCount }, m.voteCount),
+    });
+  }
+  if (m.runtime) {
+    out.push({ id: 'runtime', text: formatRuntimeMinutes(m.runtime, locale.value) });
+  }
+  if (m.genres?.length) {
+    out.push({ id: 'genres', text: m.genres.join(' · ') });
+  }
+  if (m.directors?.length) {
+    out.push({
+      id: 'directors',
+      text: t('torrents.detail.identity.director', { names: m.directors.join(', ') }),
+    });
+  }
+  return out;
+});
+
+/** La note, sur dix, avec une décimale — et rien du tout à zéro vote. */
+const score = computed(() => {
+  const v = props.media?.voteAverage;
+  if (typeof v !== 'number' || !Number.isFinite(v) || v <= 0) return null;
+  return v.toLocaleString(locale.value, {
+    minimumFractionDigits: 1,
+    maximumFractionDigits: 1,
+  });
+});
+
+/**
+ * QUEL bloc vient d'être copié, et non « quelque chose l'a été ».
+ *
+ * Il y a deux boutons pour deux textes ; un booléen partagé allumerait les
+ * deux coches à la fois, ce qui affirme une copie qui n'a pas eu lieu.
+ */
+const copied = ref<'name' | 'hash' | null>(null);
+let clearAt: ReturnType<typeof setTimeout> | null = null;
+
+async function copy(what: 'name' | 'hash') {
+  const text = what === 'name' ? props.releaseName : props.infoHash;
+  if (!text) return;
+  try {
+    await navigator.clipboard.writeText(text);
+    copied.value = what;
+    if (clearAt) clearTimeout(clearAt);
+    clearAt = setTimeout(() => (copied.value = null), 1500);
+  } catch {
+    // Contexte non sécurisé, ou permission refusée. Les deux blocs restent
+    // sélectionnables d'un clic — le bouton était un raccourci, pas le
+    // seul chemin.
+  }
+}
+
+onBeforeUnmount(() => {
+  if (clearAt) clearTimeout(clearAt);
+});
+</script>
+
+<template>
+  <div class="idc" :class="{ 'idc--plain': plain, 'idc--tinted': tint }" :style="tint ? { '--work-tint': tint } : undefined">
+    <!-- Le décor de l'œuvre, en BANDEAU et non en lavis dans une carte.
+         Décoratif : l'information est déjà dans le titre et l'affiche. Sans
+         décor, la bande reste — plus courte, unie — pour que l'affiche ait
+         toujours quelque chose à chevaucher et que la page s'ouvre au même
+         endroit d'une œuvre à l'autre. -->
+    <div
+      ref="band"
+      class="idc-band"
+      :class="{ 'idc-band--plain': !backdropUrl }"
+      :style="backdropUrl ? { '--idc-backdrop': cssUrl(backdropUrl) } : undefined"
+      aria-hidden="true"
+    >
+      <!-- La teinte de l'œuvre, sur sa propre couche pour pouvoir apparaître
+           en fondu quand l'échantillon arrive ; le grain est le `::after`. -->
+      <span class="idc-tint" />
+    </div>
+
+    <div class="idc-grid">
+      <!-- L'affiche, ou ce qui en tient la place. `role="img"` avec un nom :
+           le substitut est une information (« il n'y a pas d'affiche »), pas
+           une décoration à masquer. -->
+      <img
+        v-if="posterUrl"
+        class="idc-poster"
+        :src="posterUrl"
+        :alt="$t('torrents.detail.identity.posterAlt', { title: workTitle ?? releaseName })"
+        width="500"
+        height="750"
+        loading="eager"
+        fetchpriority="high"
+        decoding="async"
+      />
+      <div
+        v-else-if="mediaPending"
+        class="idc-poster idc-poster--loading"
+        role="img"
+        :aria-label="$t('torrents.detail.identity.posterLoading')"
+        aria-busy="true"
+      />
+      <!-- Le substitut ne se rend que quand une affiche était ATTENDUE : une
+           œuvre connue sans image. Sans métadonnées du tout, une case vide de
+           192 px ne dit rien que le titre ne dise déjà. -->
+      <div
+        v-else-if="!plain"
+        class="idc-poster idc-poster--empty"
+        role="img"
+        :aria-label="$t('torrents.detail.identity.posterUnavailable')"
+      >
+        <Icon name="ph:film-slate" class="idc-poster-glyph" aria-hidden="true" />
+        <span class="idc-poster-note">{{ $t('torrents.detail.identity.noPoster') }}</span>
+      </div>
+
+      <div class="idc-head">
+        <nav
+          v-if="crumbs?.length"
+          class="idc-crumb"
+          :aria-label="$t('torrents.detail.identity.crumbLabel')"
+        >
+          <!-- Le séparateur vit DANS le maillon : quand la ligne casse, la barre
+               ouvre la suivante au lieu de pendre au bout de la précédente, et
+               un maillon masqué emporte sa barre avec lui. -->
+          <span
+            v-for="(c, i) in crumbs"
+            :key="i"
+            class="idc-crumb-item"
+            :class="{ 'idc-crumb-item--minor': c.minor }"
+          >
+            <span v-if="i > 0" class="idc-crumb-sep" aria-hidden="true">/</span>
+            <NuxtLink v-if="c.to" :to="c.to" class="idc-crumb-link">{{ c.label }}</NuxtLink>
+            <span v-else class="idc-crumb-here">{{ c.label }}</span>
+          </span>
+        </nav>
+        <component :is="titleLevel" v-if="workTitle" class="idc-title">
+          {{ workTitle }}
+          <span v-if="year" class="idc-year">{{ year }}</span>
+        </component>
+        <p v-if="workTitle && originalTitle" class="idc-orig">
+          {{ $t('torrents.detail.identity.originalTitle', { title: originalTitle }) }}
+        </p>
+
+        <p v-if="score || meta.length" class="idc-meta">
+          <!-- `role="img"` sur le groupe entier : sans rôle, un `aria-label`
+               sur un `<span>` n'est pas exposé de façon fiable, et « 8,2 »
+               sans son échelle ne dit rien. -->
+          <span
+            v-if="score"
+            class="idc-fact idc-score"
+            role="img"
+            :aria-label="$t('torrents.detail.identity.rating', { value: score })"
+          >
+            <Icon name="ph:star-fill" aria-hidden="true" />{{ score }}
+          </span>
+          <!-- Le point sépare depuis le CSS (`::before`) et non plus comme un
+               élément à part : à 390 px sur Dune, la ligne cassait sur un
+               point — « · Science Fiction · Adventure · » orphelin en tête et
+               en queue de ligne. -->
+          <span v-for="item in meta" :key="item.id" class="idc-fact">{{ item.text }}</span>
+        </p>
+
+        <p v-if="overview" class="idc-synopsis">{{ overview }}</p>
+
+        <!-- Aucune teinte de marque sur ces pastilles, et c'est une décision :
+             le LIBELLÉ (« IMDb », « TMDb ») distingue déjà les fournisseurs,
+             et il se lit partout. -->
+        <ul
+          v-if="mediaLinks.length || (canReport && media)"
+          class="idc-ids"
+          :aria-label="$t('torrents.detail.identity.mediaLinks')"
+        >
+          <li v-for="link in mediaLinks" :key="link.id">
+            <!-- Sans lien, la pastille reste un `<span>` : un `<a>` sans
+                 `href` n'est pas focalisable et n'annonce rien. -->
+            <component
+              :is="link.href ? 'a' : 'span'"
+              class="idc-id"
+              :class="{ 'idc-id--flat': !link.href }"
+              :href="link.href || undefined"
+              :target="link.href ? '_blank' : undefined"
+              :rel="link.href ? 'noopener noreferrer' : undefined"
+              :title="
+                link.href
+                  ? $t('torrents.detail.identity.openOn', {
+                      provider: link.provider,
+                      id: link.value,
+                    })
+                  : $t('torrents.detail.identity.idNoLink', {
+                      provider: link.provider,
+                      id: link.value,
+                    })
+              "
+            >
+              <span class="idc-id-tag">{{ link.provider }}</span>
+              <span class="idc-id-val">{{ link.value }}</span>
+              <Icon
+                v-if="link.href"
+                name="ph:arrow-up-right-bold"
+                class="idc-id-out"
+                aria-hidden="true"
+              />
+            </component>
+          </li>
+          <!-- Sicario affichait la fiche de Nightcrawler et un membre n'avait
+               aucun moyen de le dire. Le motif est prérempli : le signalement
+               arrive au modérateur déjà qualifié. -->
+          <li v-if="canReport && media">
+            <button
+              type="button"
+              class="idc-id idc-id--flat idc-mismatch"
+              :title="$t('torrents.detail.identity.wrongMatchTitle')"
+              @click="emit('report-metadata')"
+            >
+              <Icon name="ph:flag-bold" class="idc-id-out" aria-hidden="true" />
+              <span class="idc-mismatch-label">{{ $t('torrents.detail.identity.wrongMatch') }}</span>
+            </button>
+          </li>
+        </ul>
+      </div>
+    </div>
+
+    <!-- La bande d'identité : ce que l'humain et le client nomment, au même
+         endroit, sous le titre — et pleine largeur, donc plus jamais une
+         colonne vide à sa gauche. -->
+    <div class="idc-strip">
+      <!-- Le bouton change d'icône et d'infobulle, rien qu'un lecteur d'écran
+           n'entende : la région vive dit « Copié » au moment où ça arrive. -->
+      <span class="sr-only" role="status">{{ copied ? $t('common.copied') : '' }}</span>
+      <div class="idc-strip-ids">
+        <div class="idc-idrow">
+          <!-- Le bouton est HORS du titre. À l'intérieur, son `aria-label`
+               entrerait dans le nom accessible du `<h1>`. -->
+          <span class="idc-relkey">{{ $t('torrents.detail.identity.releaseName') }}</span>
+          <component :is="nameHost" class="idc-relhost">
+            <code
+              class="idc-relname"
+              :class="{ 'idc-relname--solo': !workTitle }"
+              :title="releaseName"
+            ><template v-for="(chunk, i) in nameChunks" :key="i">{{ chunk }}<wbr /></template></code>
+          </component>
+          <button
+            type="button"
+            class="tool-btn tool-btn--sm"
+            :aria-label="$t('torrents.detail.identity.copyName')"
+            :title="copied === 'name' ? $t('common.copied') : $t('common.copy')"
+            @click="copy('name')"
+          >
+            <Icon
+              :name="copied === 'name' ? 'ph:check-bold' : 'ph:copy-bold'"
+              aria-hidden="true"
+            />
+          </button>
+        </div>
+
+        <div v-if="infoHash" class="idc-idrow">
+          <span class="idc-relkey">{{ $t('torrents.detail.infoHash') }}</span>
+          <code class="idc-hash">{{ infoHash }}</code>
+          <button
+            type="button"
+            class="tool-btn tool-btn--sm"
+            :aria-label="$t('torrents.detail.identity.copyHash')"
+            :title="copied === 'hash' ? $t('common.copied') : $t('common.copy')"
+            @click="copy('hash')"
+          >
+            <Icon
+              :name="copied === 'hash' ? 'ph:check-bold' : 'ph:copy-bold'"
+              aria-hidden="true"
+            />
+          </button>
+        </div>
+      </div>
+
+      <!-- Les pastilles de qualité : des faits sur CETTE release, donc dans sa
+           bande d'identité et pas dans une rangée à part. En slot parce que
+           l'analyse et les liens vers le catalogue appartiennent à la page. -->
+      <div v-if="$slots.chips || $slots.provenance" class="idc-strip-foot">
+        <div v-if="$slots.chips" class="idc-strip-chips">
+          <slot name="chips" />
+        </div>
+        <!-- Qui l'a publiée : un fait sur CETTE release, donc dans sa bande
+             d'identité, en bout de la ligne des pastilles — et plus une carte
+             à part dans la colonne de décision, où il coûtait 85 px pour deux
+             mots. -->
+        <div v-if="$slots.provenance" class="idc-strip-prov">
+          <slot name="provenance" />
+        </div>
+      </div>
+      <slot name="flags" />
+      <slot />
+    </div>
+  </div>
+</template>
+
+<style scoped>
+/* ── Pourquoi un bandeau ──────────────────────────────────────────────────
+ *
+ * Le décor TMDb était dans la charge depuis toujours et servait de lavis à
+ * 14 % à l'intérieur d'une carte. La page s'ouvrait donc sur une boîte de plus,
+ * de même poids que les douze suivantes, et l'œil n'avait nulle part où se
+ * poser. Ici le décor est un BANDEAU qui sort du cadre de la page, fondu dans
+ * son fond, et l'affiche chevauche son bord inférieur. C'est la seule audace de
+ * la page ; tout le reste est calme.
+ *
+ * Les marges négatives valent exactement ce que `<main>` (`px-4`, `py-6`) et
+ * `.release-page` (`--container-pad`, 1.25rem) ajoutent : aucun `vw`, donc
+ * aucune barre de défilement comptée deux fois — c'est ce qui faisait déborder
+ * sept décors « pleine largeur » sur ce site. Le bandeau s'arrête au bord de
+ * `<main>`, soit la fenêtre jusqu'à 1400 px, puis un ruban centré.
+ */
+.idc {
+  --idc-poster-w: clamp(6.5rem, 15vw, 12rem);
+  /* La partie de l'affiche qui monte sur le bandeau. */
+  --idc-overlap: clamp(4rem, 9vw, 7.5rem);
+  display: block;
+}
+
+.idc-band {
+  position: relative;
+  overflow: hidden;
+  height: clamp(13rem, 30vw, 24rem);
+  margin: calc(-1 * (1.25rem + 1.5rem)) calc(-1 * (var(--container-pad) + 1rem)) 0;
+  background-color: rgb(var(--bg-elevated));
+  /* Le voile : de presque rien en haut à la couleur de la page en bas, pour
+     que le décor ait un bord haut net (l'en-tête) et pas de bord bas. */
+  mask-image: linear-gradient(
+    to bottom,
+    rgb(0 0 0 / 0.72) 0%,
+    rgb(0 0 0 / 0.42) 55%,
+    transparent 100%
+  );
+}
+/* En thème clair, un décor à pleine force écrase le titre qu'on pose dessus :
+   le masque laisse passer moins. Mesuré sur l'affiche de Frieren, le blanc du
+   ciel derrière un titre noir tenait 7,2:1 avec ce réglage, 4,1:1 sans. */
+:root[data-theme='light'] .idc-band {
+  mask-image: linear-gradient(
+    to bottom,
+    rgb(0 0 0 / 0.42) 0%,
+    rgb(0 0 0 / 0.22) 55%,
+    transparent 100%
+  );
+}
+/* L'image sur sa propre couche. Sous 48 rem, elle EST le cadre : le cadrage
+   `center 28%` d'origine, rien qui bouge. À partir de 48 rem, la couche est
+   24 % plus haute que le cadre, calée en haut de l'image : au repos, le cadre
+   montre exactement ce que `center 28%` montrait (mesuré à 1280 : les lignes
+   92 à 476 de l'image contre 94 à 478 avant), et la marge du dessus est ce que
+   le glissement consomme. Le masque est sur le cadre : le voile reste en place
+   pendant que le décor bouge dessous. */
+.idc-band::before {
+  content: '';
+  position: absolute;
+  inset: 0;
+  background-image: var(--idc-backdrop);
+  background-size: cover;
+  background-position: center 28%;
+}
+@media (min-width: 48rem) {
+  .idc-band::before {
+    inset: -24% 0 0 0;
+    background-position: center top;
+    transform: translate3d(0, var(--idc-drift, 0px), 0);
+    will-change: transform;
+  }
+}
+.idc-band--plain::before { display: none; }
+/* Le grain : un bruit SVG à 6 % d'alpha, pour que le voile ne fasse pas de
+   bandes sur les grands écrans. Invisible en tant que tel. */
+.idc-band::after {
+  content: '';
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='160' height='160'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.85' numOctaves='2' stitchTiles='stitch'/%3E%3CfeColorMatrix values='0 0 0 0 0.5 0 0 0 0 0.5 0 0 0 0 0.5 0 0 0 0.06 0'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)'/%3E%3C/svg%3E");
+  background-size: 160px 160px;
+}
+.idc-band--plain::after { display: none; }
+/* La teinte : du haut vers rien à 70 % du bandeau, apparue en fondu. */
+.idc-tint {
+  position: absolute;
+  inset: 0;
+  pointer-events: none;
+  background: linear-gradient(to bottom, rgb(var(--work-tint, 0 0 0) / 0.18), rgb(var(--work-tint, 0 0 0) / 0) 70%);
+  opacity: 0;
+  transition: opacity var(--dur-slow) var(--ease-standard);
+}
+.idc--tinted .idc-tint { opacity: 1; }
+.idc-band--plain .idc-tint { display: none; }
+
+/* ── L'entrée en scène : le décor se révèle, l'affiche monte, le titre suit ─
+   Une seule séquence, sous 400 ms, et rien d'autre ne bouge au chargement.
+   `backwards` sur le décor : à la fin, c'est sa règle propre (le glissement)
+   qui reprend le `transform`, pas la dernière image de l'animation. */
+@keyframes idc-develop {
+  from { opacity: 0; transform: translate3d(0, var(--idc-drift, 0px), 0) scale(1.03); }
+}
+@keyframes idc-rise {
+  from { opacity: 0; transform: translateY(0.5rem); }
+}
+.idc-band::before {
+  animation: idc-develop var(--dur-slow) var(--ease-emphasis) backwards;
+}
+.idc-poster,
+.idc-poster--empty {
+  animation: idc-rise var(--dur-4) var(--ease-emphasis) both;
+  animation-delay: calc(80ms * var(--motion-scale));
+}
+.idc-head,
+.idc-strip {
+  animation: idc-rise var(--dur-4) var(--ease-emphasis) both;
+  animation-delay: calc(160ms * var(--motion-scale));
+}
+@media (prefers-reduced-motion: reduce) {
+  .idc-band::before,
+  .idc-poster,
+  .idc-poster--empty,
+  .idc-head,
+  .idc-strip { animation: none; }
+  .idc-tint { transition: none; }
+}
+@media (prefers-reduced-motion: reduce) {
+  .idc-band::before { transform: none; }
+}
+/* Sans décor : une bande unie, plus courte. L'affiche a toujours un bord à
+   chevaucher et la page s'ouvre au même endroit d'une œuvre à l'autre. */
+.idc-band--plain {
+  height: clamp(8rem, 16vw, 12rem);
+  background-image: var(--bg-pattern-image);
+  background-size: 12px 12px;
+  mask-image: linear-gradient(to bottom, rgb(0 0 0 / 0.5), transparent);
+}
+@media (prefers-reduced-motion: reduce) {
+  .idc-band {
+    mask-image: linear-gradient(to bottom, rgb(0 0 0 / 0.35), transparent);
+  }
+}
+/* Sans métadonnées : une entrée de page, pas un héros. Le bandeau devient un
+   seuil de 7 à 9 rem, le titre — s'il y en a un — prend toute la largeur, et
+   l'affiche n'a plus de place réservée puisqu'il n'y en aura pas. */
+.idc--plain {
+  --idc-overlap: 1.25rem;
+}
+.idc--plain .idc-band {
+  height: clamp(7rem, 12vw, 9rem);
+}
+.idc--plain .idc-grid {
+  grid-template-columns: minmax(0, 1fr);
+}
+.idc--plain .idc-title {
+  font-size: clamp(1.5rem, 3vw, 2.25rem);
+}
+
+.idc-grid {
+  display: grid;
+  grid-template-columns: var(--idc-poster-w) minmax(0, 1fr);
+  gap: clamp(1rem, 2.5vw, 2rem);
+  align-items: end;
+  margin-top: calc(-1 * var(--idc-overlap));
+  position: relative;
+}
+
+.idc-poster {
+  /* La boîte est réservée par `width` + `aspect-ratio` : aucun décalage de
+     mise en page à l'arrivée du fichier. Les attributs `width`/`height` de la
+     balise servent de repli si cette règle ne s'applique pas. `eager` et
+     `fetchpriority="high"` : c'est la seule image du premier écran. */
+  width: 100%;
+  aspect-ratio: 2 / 3;
+  display: block;
+  object-fit: cover;
+  background-color: rgb(var(--bg-inset));
+  border: 1px solid rgb(var(--line-strong));
+  border-radius: var(--radius-lg);
+  /* Deux ombres : la portée, et un filet de la couleur de la page qui détache
+     l'affiche du décor quel que soit le pixel derrière. */
+  box-shadow:
+    var(--shadow-overlay),
+    0 0 0 1px rgb(var(--bg-base));
+}
+.idc-poster--loading {
+  background: linear-gradient(
+    100deg,
+    rgb(var(--bg-inset)) 30%,
+    rgb(var(--bg-hover)) 50%,
+    rgb(var(--bg-inset)) 70%
+  );
+  background-size: 220% 100%;
+  animation: idc-poster-sweep 1.4s ease-in-out infinite;
+}
+@keyframes idc-poster-sweep {
+  from { background-position: 120% 0; }
+  to { background-position: -20% 0; }
+}
+@media (prefers-reduced-motion: reduce) {
+  .idc-poster--loading { animation: none; }
+}
+.idc-poster--empty {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 0.15rem;
+  background-image: var(--bg-pattern-image);
+  background-size: 12px 12px;
+  overflow: hidden;
+  text-align: center;
+  color: rgb(var(--fg-muted));
+}
+.idc-poster-glyph { font-size: 1.1875rem; line-height: 1; }
+.idc-poster-note {
+  padding: 0 0.2rem;
+  font-size: 0.5625rem;
+  letter-spacing: calc(0.04em * var(--tracking-scale));
+  line-height: 1.2;
+}
+
+.idc-head {
+  min-width: 0;
+  padding-bottom: 0.25rem;
+}
+.idc-head > * + * { margin-top: 0.45rem; }
+
+/* Le titre de l'œuvre dans la police d'affiche du site — celle des titres de
+   page (`/stats`) et des en-têtes de section, en italique comme eux. Il était
+   en Inter à 21 px, plus petit que les sous-titres de sa propre page. */
+.idc-title {
+  margin: 0;
+  font-family: var(--font-display);
+  font-style: italic;
+  font-weight: 500;
+  font-size: clamp(1.75rem, 3.6vw, 2.75rem);
+  line-height: 1.04;
+  letter-spacing: calc(-0.02em * var(--tracking-scale));
+  color: rgb(var(--fg-strong));
+  text-wrap: balance;
+  overflow-wrap: anywhere;
+}
+.idc-year {
+  margin-left: 0.3em;
+  font-style: normal;
+  font-weight: 500;
+  font-size: 0.6em;
+  letter-spacing: 0;
+  color: rgb(var(--fg-muted));
+  font-variant-numeric: tabular-nums;
+}
+.idc-orig {
+  margin: 0;
+  font-size: 0.8125rem;
+  color: rgb(var(--fg-muted));
+}
+.idc-meta {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 0.3rem 0;
+  /* Chaque fait porte son point dans une marge gauche de 1.1rem ; la ligne
+     est décalée d'autant et rognée d'autant : le point d'un fait qui ouvre une
+     ligne tombe dans la zone rognée, celui d'un fait en milieu de ligne se
+     lit entre ses voisins. Aucun point orphelin, quelle que soit la casse. */
+  margin: 0 0 0 -1.1rem;
+  clip-path: inset(0 0 0 1.1rem);
+  font-size: 0.8125rem;
+  color: rgb(var(--fg-muted));
+  font-variant-numeric: tabular-nums;
+}
+.idc-fact {
+  position: relative;
+  padding-left: 1.1rem;
+}
+.idc-fact::before {
+  content: '·' / '';
+  position: absolute;
+  left: 0.3rem;
+  color: rgb(var(--fg-subtle));
+}
+.idc-score {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  font-weight: 700;
+  color: rgb(var(--accent-warm-text));
+}
+.idc-synopsis {
+  margin: 0;
+  max-width: 62ch;
+  font-size: 0.875rem;
+  line-height: 1.5;
+  color: rgb(var(--fg-muted));
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+}
+
+.idc-crumb {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.3rem 0.5rem;
+  font-family: var(--font-mono);
+  font-size: var(--label-md, 0.625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+}
+.idc-crumb-link {
+  /* WCAG 2.5.8 : 24 px de cible, dans une rangée qui ne fait que 10 px de
+     texte. */
+  display: inline-flex;
+  align-items: center;
+  min-height: 1.5rem;
+  color: rgb(var(--fg-muted));
+  text-decoration: none;
+  transition: color var(--dur-1) var(--ease-standard);
+}
+.idc-crumb-link:hover {
+  color: rgb(var(--fg-strong));
+}
+.idc-crumb-item {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+.idc-crumb-sep { color: rgb(var(--fg-subtle)); }
+/* À 390 px, « Frieren: Beyond Journey's End » prenait une ligne à lui seul —
+   et le titre, 40 px plus bas, le répète en Fraunces. Sous 40 rem le fil garde
+   la catégorie et l'unité, ce que le titre ne dit pas. */
+@media (max-width: 40rem) {
+  .idc-crumb-item--minor { display: none; }
+}
+/* Le dernier maillon — l'unité qu'on regarde — dans l'or du site. */
+.idc-crumb-here { color: rgb(var(--accent-warm-text)); }
+
+.idc-ids {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.3rem;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+.idc-id {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. */
+  min-height: 1.6rem;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  padding: 0.15rem 0.5rem;
+  font-size: var(--label-md, 0.625rem);
+  font-weight: 700;
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  text-decoration: none;
+  color: rgb(var(--fg-default));
+  background-color: rgb(var(--bg-surface));
+  border: 1px solid rgb(var(--line-default));
+  border-radius: var(--radius-sm);
+  transition:
+    background-color var(--dur-2) ease,
+    border-color var(--dur-2) ease;
+}
+a.idc-id:hover {
+  background-color: rgb(var(--bg-hover));
+  border-color: rgb(var(--line-strong));
+}
+.idc-id-val {
+  font-family: var(--font-mono);
+  font-weight: 500;
+  letter-spacing: 0;
+  text-transform: none;
+  color: rgb(var(--fg-muted));
+}
+.idc-id-out { font-size: 0.625rem; color: rgb(var(--fg-muted)); }
+.idc-id--flat { cursor: default; }
+/* Un bouton parmi des pastilles : même boîte, mais un libellé en minuscules et
+   la couleur de commande — c'est une action, pas un fait sur l'œuvre. */
+.idc-mismatch {
+  cursor: pointer;
+  text-transform: none;
+  letter-spacing: 0;
+  font-weight: 500;
+  color: rgb(var(--fg-muted));
+  font-family: var(--font-sans);
+}
+.idc-mismatch:hover {
+  color: rgb(var(--fg-strong));
+  background-color: rgb(var(--bg-hover));
+  border-color: rgb(var(--line-strong));
+}
+.idc-mismatch-label { font-size: 0.6875rem; }
+
+/* ── La bande d'identité ─────────────────────────────────────────────────── */
+.idc-strip {
+  margin-top: 1.25rem;
+  padding: 0.85rem 1rem;
+  border: 1px solid rgb(var(--line-default));
+  border-radius: var(--radius-xl);
+  background: rgb(var(--bg-surface));
+  display: grid;
+  gap: 0.75rem;
+}
+.idc-strip-ids {
+  display: grid;
+  gap: 0.5rem;
+}
+.idc-idrow {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 0.25rem 0.75rem;
+  align-items: center;
+}
+.idc-relkey {
+  grid-column: 1 / -1;
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+}
+/* À partir de 640 px, la clé prend sa colonne et la valeur la suit. */
+@media (min-width: 640px) {
+  .idc-idrow { grid-template-columns: 7.5rem minmax(0, 1fr) auto; }
+  .idc-relkey { grid-column: auto; }
+}
+.idc-relhost {
+  min-width: 0;
+  margin: 0;
+  font-size: inherit;
+  font-weight: inherit;
+}
+.idc-relname {
+  display: block;
+  padding: 0.4rem 0.5rem;
+  font-family: var(--font-mono);
+  font-size: clamp(0.75rem, 1.4vw, 0.84375rem);
+  line-height: 1.35;
+  font-weight: 600;
+  color: rgb(var(--fg-strong));
+  background-color: rgb(var(--bg-inset));
+  border: 1px solid rgb(var(--line-default));
+  border-left: 3px solid rgb(var(--accent-warm));
+  border-radius: var(--radius-sm);
+  overflow-wrap: anywhere;
+  /* Un seul clic sélectionne le nom entier — ce qu'un membre vient chercher
+     ici neuf fois sur dix. */
+  user-select: all;
+  cursor: text;
+}
+/* Sans métadonnées — le cas COURANT — ce bloc est le titre de la page. */
+.idc-relname--solo {
+  font-size: clamp(0.875rem, 1.8vw, 1rem);
+}
+.idc-hash {
+  display: block;
+  padding: 0.3rem 0.5rem;
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  line-height: 1.35;
+  letter-spacing: calc(0.02em * var(--tracking-scale));
+  color: rgb(var(--fg-default));
+  background-color: rgb(var(--bg-inset));
+  border: 1px solid rgb(var(--line-default));
+  border-radius: var(--radius-sm);
+  /* 40 caractères en SHA-1, 64 en BEP 52, et aucun espace. */
+  word-break: break-all;
+  user-select: all;
+  cursor: text;
+}
+.idc-strip-foot {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.5rem 1.25rem;
+  padding-top: 0.75rem;
+  border-top: 1px solid rgb(var(--line-default));
+}
+.idc-strip-chips {
+  flex: 1 1 16rem;
+  min-width: 0;
+}
+/* À droite tant que la ligne le permet ; en dessous des pastilles sinon. */
+.idc-strip-prov {
+  flex: 0 1 auto;
+  margin-left: auto;
+  min-width: 0;
+}
+
+@media (max-width: 767px) {
+  .idc { --idc-poster-w: 5.5rem; --idc-overlap: 3rem; }
+  /* Les deux pilules de commande flottent sur le haut du bandeau (jusqu'à
+     ~84 px quand elles se replient sur deux lignes) : un bandeau court doit
+     rester plus haut qu'elles, sinon le titre monte dessous. */
+  .idc--plain { --idc-overlap: 0.5rem; }
+  /* 8,5 rem et non 7 : à 375 px les deux pilules se replient sur deux lignes
+     et descendent jusqu'à 165 px ; un bandeau de 7 rem posait le titre à 161.
+     Mesuré, puis remesuré : 8,5 rem le pose à 185. */
+  .idc--plain .idc-band { height: 8.5rem; }
+  .idc-band { margin-left: calc(-1 * (var(--container-pad) + 1rem)); margin-right: calc(-1 * (var(--container-pad) + 1rem)); }
+  .idc-strip { padding: 0.7rem 0.75rem; }
+}
+</style>
\ No newline at end of file
diff --git a/apps/web/app/components/torrent/detail/NfoPanel.vue b/apps/web/app/components/torrent/detail/NfoPanel.vue
new file mode 100644
index 00000000..95128a64
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/NfoPanel.vue
@@ -0,0 +1,196 @@
+<script setup lang="ts">
+/**
+ * Le NFO, replié, et rendu au caractère près.
+ *
+ * # Pourquoi replié
+ *
+ * Un NFO fait couramment 60 lignes de dessin ASCII. Déplié il pousse les
+ * commentaires et les cross-seeds à 2000 px du haut de page ; replié il coûte
+ * 40 px. Le compte va dans le libellé — « NFO (10 lignes) » — pour que le
+ * choix de l'ouvrir se fasse sans l'ouvrir.
+ *
+ * # Pourquoi tout ce fatras typographique
+ *
+ * Un NFO n'est pas du texte : c'est une image dessinée avec des caractères de
+ * la page de code 437, et elle ne tient que si chaque glyphe occupe exactement
+ * une cellule. Quatre réglages la cassent, et trois sont des DÉFAUTS :
+ *
+ *   - `liga` / `calt` — JetBrains Mono, la police mono du site, a des
+ *     ligatures : `--` devient un tiret long, `|-` une flèche. Un cadre en
+ *     `+---+` se referme d'un caractère.
+ *   - `kern` / `font-kerning` — le crénage rapproche certaines paires. Sur une
+ *     mono le pas doit être invariant, sinon les colonnes d'un tableau ASCII
+ *     ne s'empilent plus.
+ *   - `letter-spacing` — la fiche en pose ailleurs, et il s'hérite.
+ *   - `line-height` — les caractères de dessin (`─│┌┐└┘`) touchent le haut et
+ *     le bas de leur cellule. À 1.35 un cadre a des trous horizontaux ; à 1 il
+ *     est continu.
+ *
+ * Et une pile mono explicite plutôt que `var(--font-mono)` : ce jeton est
+ * modifiable par l'exploitant depuis la console des thèmes, et un NFO rendu
+ * dans une police proportionnelle n'est plus lisible du tout. Le jeton reste en
+ * tête de pile, avec de vraies mono derrière.
+ */
+import { formatSize } from '~/utils/format';
+
+const props = defineProps<{
+  /** Le texte brut, tel qu'il est stocké. Vide, la section ne se rend pas. */
+  nfo: string | null | undefined;
+}>();
+
+const { t } = useI18n();
+const { open, toggle, forced } = useDetailDisclosure();
+const fid = useFieldIds();
+
+const lineCount = computed(() => (props.nfo ? props.nfo.split('\n').length : 0));
+
+/** Les octets, pas les caractères : un NFO en CP437 étendu pèse plus qu'il ne compte. */
+const byteSize = computed(() =>
+  props.nfo ? formatSize(new TextEncoder().encode(props.nfo).length) : '',
+);
+
+const hint = computed(() =>
+  `${t('torrents.detail.nfoMeta.lines', { n: lineCount.value })} · ${byteSize.value}`,
+);
+
+/* ── La copie ─────────────────────────────────────────────────────────────── */
+
+const copied = ref(false);
+let resetTimer: ReturnType<typeof setTimeout> | undefined;
+
+async function copy() {
+  if (!props.nfo) return;
+  try {
+    await navigator.clipboard.writeText(props.nfo);
+    copied.value = true;
+    clearTimeout(resetTimer);
+    resetTimer = setTimeout(() => (copied.value = false), 1500);
+  } catch {
+    // Presse-papiers refusé (contexte non sécurisé, permission) : le bouton ne
+    // mentira pas en affichant « copié ».
+    copied.value = false;
+  }
+}
+
+onBeforeUnmount(() => clearTimeout(resetTimer));
+</script>
+
+<template>
+  <section v-if="nfo" class="nfo-panel">
+    <SectionHead
+      :flush="!open"
+      :title="$t('torrents.detail.sections.nfo')"
+      :count="lineCount"
+      icon="ph:file-text-bold"
+    >
+      <template #action>
+        <span class="nfo-hint">{{ hint }}</span>
+        <button
+          v-if="open"
+          type="button"
+          class="tool-btn tool-btn--sm tool-btn--text"
+          @click="copy"
+        >
+          <Icon :name="copied ? 'ph:check-bold' : 'ph:copy-bold'" aria-hidden="true" />
+          {{ copied ? $t('common.copied') : $t('common.copy') }}
+        </button>
+        <!-- `aria-expanded` porté par le bouton et `aria-controls` désignant le
+             corps : sans les deux, un lecteur d'écran annonce « bouton » et rien
+             sur l'état. Le bouton se désactive quand « tout afficher » tient
+             l'ouverture, plutôt que de mentir sur ce qu'un clic ferait. -->
+        <button
+          type="button"
+          class="tool-btn tool-btn--sm"
+          :aria-expanded="open"
+          :aria-controls="fid('nfo-body')"
+          :disabled="forced"
+          :aria-label="open
+            ? $t('torrents.detail.nfoPanel.collapse')
+            : $t('torrents.detail.nfoPanel.expand')"
+          @click="toggle"
+        >
+          <Icon
+            name="ph:caret-down-bold"
+            class="nfo-caret"
+            :class="{ 'nfo-caret--open': open }"
+            aria-hidden="true"
+          />
+        </button>
+      </template>
+    </SectionHead>
+
+    <div v-show="open" :id="fid('nfo-body')" class="nfo-frame">
+      <pre class="nfo-body">{{ nfo }}</pre>
+    </div>
+  </section>
+</template>
+
+<style scoped>
+/* La famille « contenu » de la fiche — le NFO, les pistes audio, les
+   sous-titres : ce que le FICHIER contient, par opposition à ce que la release
+   vaut (or) ou à ce que l'équipe en fait (bleu). `--accent-cool` était déclaré
+   dans `main.css` et n'était utilisé nulle part ; c'est exactement la matière
+   première qui manquait. `SectionHead` l'hérite sans qu'on lui passe rien. */
+.nfo-panel {
+  --section-tone: var(--accent-cool);
+}
+
+.nfo-hint {
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  color: rgb(var(--fg-muted));
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+}
+
+.nfo-caret {
+  transition: transform var(--dur-2) var(--ease-standard);
+}
+.nfo-caret--open { transform: rotate(180deg); }
+
+/* Le cadre du NFO : un voile de la teinte de famille à 6 %, sous une encre
+   NEUTRE. Un NFO est un artefact de terminal, et un fond très légèrement
+   refroidi le dit sans rien coûter à la lisibilité — mesuré, `--fg-default`
+   sur un voile de `--accent-cool` à 6 % donne 15,01:1 en sombre et 16,96:1 en
+   clair. Le liseré de tête est non textuel (3:1 requis) : `--accent-cool` sur
+   ces surfaces donne 8,65:1 et 3,44:1. */
+.nfo-frame {
+  background:
+    linear-gradient(rgb(var(--accent-cool) / 0.06), rgb(var(--accent-cool) / 0.06)),
+    rgb(var(--bg-inset));
+  border: 1px solid rgb(var(--accent-cool) / 0.28);
+  border-top: 2px solid rgb(var(--accent-cool) / 0.5);
+  border-radius: var(--radius-md);
+  padding: 0.7rem 0.8rem;
+  overflow: auto;
+  max-height: 70vh;
+}
+
+/*
+ * La fidélité ASCII, réglage par réglage. Chacun corrige un défaut du
+ * navigateur ou un héritage de la page — voir l'en-tête du fichier.
+ */
+.nfo-body {
+  margin: 0;
+  font-family:
+    var(--font-mono), ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas,
+    'DejaVu Sans Mono', monospace;
+  font-size: 0.75rem;
+  /* Une cellule = une ligne. Les caractères de dessin touchent leurs bords. */
+  line-height: 1;
+  /* Pas de ligature, pas de crénage, pas d'interlettrage : le pas est
+     invariant, sinon les colonnes d'un cadre ne s'empilent plus. */
+  font-variant-ligatures: none;
+  font-feature-settings: 'liga' 0, 'clig' 0, 'calt' 0, 'kern' 0;
+  font-kerning: none;
+  letter-spacing: 0;
+  font-variant-numeric: normal;
+  color: rgb(var(--fg-default));
+  white-space: pre;
+  tab-size: 4;
+  /* Un NFO est centré pour un terminal à largeur fixe : garder sa largeur
+     naturelle évite le retour à la ligne qui détruit le dessin. */
+  width: max-content;
+  min-width: 100%;
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/OperatorArea.vue b/apps/web/app/components/torrent/detail/OperatorArea.vue
new file mode 100644
index 00000000..81b1695f
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/OperatorArea.vue
@@ -0,0 +1,277 @@
+<script setup lang="ts">
+import AdminSwarmTable from './AdminSwarmTable.vue';
+import BuffsForm from './BuffsForm.vue';
+import FederationSwarmToggle from './FederationSwarmToggle.vue';
+import SupersedeForm from './SupersedeForm.vue';
+
+/**
+ * Tout ce qu'un exploitant voit et qu'un membre ne voit pas, au même endroit.
+ *
+ * # Pourquoi un seul bloc
+ *
+ * Les quatre outils étaient DISPERSÉS dans la page, entrelacés avec le contenu
+ * public. Deux conséquences, toutes deux mesurées sur l'ancienne page :
+ *
+ *   1. La page d'un simple membre portait des TROUS là où les blocs de
+ *      personnel se seraient trouvés — quatre `v-if` répartis sur 200 lignes de
+ *      gabarit, donc quatre ruptures de rythme dans une page qui n'en montrait
+ *      aucune raison.
+ *   2. Le panneau de modération d'un UPLOADEUR se rendait SOUS la table des
+ *      pairs d'un administrateur. Deux publics différents, une seule pile, dans
+ *      l'ordre où le code avait été écrit.
+ *
+ * Regroupé par AUDIENCE plutôt que par fonctionnalité, il n'y a plus qu'une
+ * frontière : au-dessus ce que tout le monde lit, ici ce que seul un exploitant
+ * peut faire.
+ *
+ * # L'ordre à l'intérieur
+ *
+ * Du plus éditorial au plus technique : ce que la release COÛTE (les
+ * multiplicateurs), ce qu'elle EST devenue (remplacée ou non), avec qui son
+ * swarm est partagé, puis qui est dedans. Les trois premiers écrivent, le
+ * dernier ne fait que lire.
+ *
+ * # Les gardes
+ *
+ * Chaque bloc porte la sienne, et elles ne se recouvrent pas : épingler et
+ * remplacer sont des actes de modération ; l'interrupteur de fédération
+ * appartient à qui peut éditer la release, donc aussi à son uploadeur ; la
+ * liste des pairs est de la donnée d'exploitation, réservée aux
+ * administrateurs. Quand aucune ne passe, la région entière ne se rend pas —
+ * un cadre vide serait précisément le trou qu'on vient de supprimer.
+ */
+const props = withDefaults(
+  defineProps<{
+    /** Le hash de la release, tel qu'il est dans la route. */
+    hash: string;
+    /**
+     * La ligne du torrent. Tous les champs sont optionnels : le détail arrive
+     * en `Record<string, any>` et rien n'y est garanti présent.
+     */
+    torrent?: {
+      infoHash?: string;
+      federateSwarm?: boolean;
+      downloadMultiplier?: number;
+      uploadMultiplier?: number;
+      multipliersUntil?: string | null;
+      isSticky?: boolean;
+      peers?: Array<{
+        id: string;
+        port: number;
+        isSeeder: boolean;
+        uploaded: number;
+        downloaded: number;
+        lastSeen: string;
+      }>;
+    } | null;
+    /** Les deux sens du pointeur de remplacement ; seul l'aller sert ici. */
+    supersessions?: { supersededBy?: { name?: string | null } | null } | null;
+    /** Modérateur ou administrateur : buffs et remplacement. */
+    isStaff?: boolean;
+    /** Administrateur : les multiplicateurs, et la liste des pairs. */
+    isAdmin?: boolean;
+    /** Uploadeur ou personnel : l'interrupteur de fédération du swarm. */
+    canEdit?: boolean;
+    /** Sans partenaire, l'interrupteur de fédération n'a rien à commuter. */
+    federationEnabled?: boolean;
+  }>(),
+  {
+    torrent: null,
+    supersessions: null,
+    isStaff: false,
+    isAdmin: false,
+    canEdit: false,
+    federationEnabled: false,
+  },
+);
+
+const emit = defineEmits<{
+  /**
+   * Une écriture a abouti quelque part dans la région. La page recharge ce
+   * qu'elle veut — la ligne, les supersessions, ou les deux.
+   */
+  (e: 'changed'): void;
+}>();
+
+/** L'interrupteur de fédération : le seul bloc ouvert à un uploadeur. */
+const showFederation = computed(() => props.canEdit && props.federationEnabled);
+
+/** Rien à montrer, rien à encadrer. */
+const showArea = computed(
+  () => props.isStaff || props.isAdmin || showFederation.value,
+);
+
+/**
+ * `infoHash` de la ligne pour la route de fédération, `hash` de la route pour
+ * les deux routes de modération. C'est ce que faisait la page, à la lettre :
+ * l'un vient de la base en minuscules, l'autre de l'URL telle qu'elle a été
+ * tapée, et les deux routes n'ont jamais été appelées avec la même source.
+ */
+const federationHash = computed(() => props.torrent?.infoHash || props.hash);
+
+/* Le titre de la région est désigné par `aria-labelledby`, donc il lui faut un
+   `id` unique : `useFieldIds` est ce qui garantit l'unicité quand deux
+   instances du composant coexistent. */
+const fid = useFieldIds();
+</script>
+
+<template>
+  <section
+    v-if="showArea"
+    class="operator-area"
+    :aria-labelledby="fid('operator-area')"
+  >
+    <!-- Le nom de la région devient VISIBLE.
+         Il n'existait qu'en `aria-label` : un lecteur d'écran savait qu'il
+         entrait dans « Outils d'exploitation », l'œil ne le savait pas — et à
+         l'écran, quatre cartes au conteneur identique à celui des sections
+         publiques défilaient sans que rien ne dise « à partir d'ici, c'est
+         l'équipe ». `aria-labelledby` pointant sur un texte affiché est en
+         outre préférable à un `aria-label` invisible : les deux publics lisent
+         alors la même chose, et la traduction ne peut plus dériver d'un côté
+         sans l'autre. La chaîne est celle qui servait déjà. -->
+    <p :id="fid('operator-area')" class="operator-area__label">
+      <span class="operator-area__plate" aria-hidden="true">
+        <Icon name="ph:wrench-bold" class="operator-area__icon" />
+      </span>
+      {{ $t('torrents.detail.operator.area') }}
+    </p>
+
+    <BuffsForm
+      v-if="isStaff"
+      :hash="hash"
+      :torrent="torrent"
+      :is-admin="isAdmin"
+      @changed="emit('changed')"
+    />
+
+    <SupersedeForm
+      v-if="isStaff"
+      :hash="hash"
+      :superseded-by="supersessions?.supersededBy ?? null"
+      @changed="emit('changed')"
+    />
+
+    <FederationSwarmToggle
+      v-if="showFederation"
+      :hash="federationHash"
+      :enabled="!!torrent?.federateSwarm"
+    />
+
+    <AdminSwarmTable v-if="isAdmin" :peers="torrent?.peers ?? []" />
+  </section>
+</template>
+
+<style scoped>
+/* La région est un regroupement, pas une carte — mais elle doit se VOIR comme
+   un regroupement. Elle ne portait ni fond, ni filet, ni titre : ses quatre
+   cartes se lisaient donc comme quatre sections publiques de plus, dans un
+   document de 3 830 px où treize conteneurs étaient rigoureusement identiques.
+
+   Elle porte maintenant, en plus du titre visible : un filet de tête en
+   dégradé, un très léger voile de la teinte de famille, et un retrait à
+   gauche. Le voile est à 4 % et ne porte que des cartes opaques — aucune
+   paire texte/fond n'y repose. */
+.operator-area {
+  --section-tone: var(--chart-1);
+  display: flex;
+  flex-direction: column;
+  gap: 1.25rem;
+  padding: 1rem 0 0.25rem 0.9rem;
+  border-top: 1px solid rgb(var(--line-default));
+  border-left: 1px solid rgb(var(--chart-1) / 0.28);
+  border-radius: var(--radius-lg) 0 0 var(--radius-lg);
+  background:
+    linear-gradient(
+      to bottom,
+      rgb(var(--chart-1) / 0.05),
+      rgb(var(--chart-1) / 0)
+    ),
+    transparent;
+  background-size: 100% 12rem, auto;
+  background-repeat: no-repeat;
+}
+/* Le filet de tête reprend le dégradé de `SectionHead` : la teinte à gauche,
+   le gris de filet ensuite, l'extinction. Non textuel. */
+.operator-area::before {
+  content: '';
+  display: block;
+  height: 2px;
+  margin: -1rem 0 0.25rem -0.9rem;
+  background: linear-gradient(
+    to right,
+    rgb(var(--chart-1) / 0.7),
+    rgb(var(--line-default)) 10rem,
+    rgb(var(--line-default) / 0)
+  );
+}
+
+.operator-area__label {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  margin: 0;
+  /* `rem` et non `px` : `--ui-scale` n'agit qu'une fois, sur
+     `html { font-size }`. */
+  font-family: var(--font-mono);
+  font-size: var(--label-lg, 0.6875rem);
+  font-weight: 700;
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+}
+/* Plaque NEUTRE, glyphe teinté — une teinte sur un voile d'elle-même tombe
+   sous 3:1 en thème clair. */
+.operator-area__plate {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex: none;
+  width: 1.35rem;
+  height: 1.35rem;
+  background: rgb(var(--bg-inset));
+  border: 1px solid rgb(var(--chart-1) / 0.45);
+  border-radius: var(--radius-xs);
+}
+.operator-area__icon {
+  font-size: 0.75rem;
+  color: rgb(var(--chart-1));
+}
+
+@media (max-width: 767px) {
+  .operator-area {
+    /* Le retrait mange une largeur qu'un téléphone n'a pas : le filet de tête
+       et le titre suffisent à marquer la frontière. */
+    padding-left: 0;
+    border-left: 0;
+    border-radius: 0;
+  }
+  .operator-area::before {
+    margin-left: 0;
+  }
+}
+
+/* ── Pas de carte DANS la carte ────────────────────────────────────────────
+ *
+ * Depuis que la page donne une coquille à chacun de ses blocs de premier rang,
+ * la zone opérateur en est une — et ses trois enfants (bonus, remplacement,
+ * liste des pairs) en dessinaient une chacun : même surface, même filet, même
+ * rayon, imbriqués. Un cadre dans un cadre de la même couleur ne hiérarchise
+ * rien, il épaissit.
+ *
+ * Ils sont donc séparés par un filet, comme les bandes de la carte de
+ * décision — c'est déjà l'idiome de cette page pour « des sujets voisins dans
+ * un même conteneur ». La racine d'un composant enfant porte le scope de son
+ * parent, d'où ce sélecteur depuis ici.
+ */
+.operator-area > .section {
+  border: 0;
+  border-radius: 0;
+  background: none;
+  padding: 0.9rem 0 0;
+}
+.operator-area > .section + .section {
+  margin-top: 0.9rem;
+  border-top: 1px solid rgb(var(--line-default));
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/ProvenanceRow.vue b/apps/web/app/components/torrent/detail/ProvenanceRow.vue
new file mode 100644
index 00000000..4d873f41
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/ProvenanceRow.vue
@@ -0,0 +1,346 @@
+<script setup lang="ts">
+import { tagsBeyondChips } from '~/utils/chipTagOverlap';
+/**
+ * D'où vient cette publication, et sous quelles étiquettes.
+ *
+ * # Pourquoi ce n'est PAS dans la carte d'identité
+ *
+ * `IdentityCard` répond à « qu'est-ce que c'est, et de quelle release
+ * parle-t-on » : l'œuvre, son affiche, ses fiches publiques, le nom de release
+ * et l'infohash. Les deux informations d'ici sont d'une autre nature — ce sont
+ * les seules de tout le haut de page qui pointent AILLEURS que vers ce
+ * torrent : vers un profil, et vers le catalogue filtré. Elles répondent à
+ * « qui l'a publiée, et par où continuer », pas à « qu'est-ce que c'est ».
+ *
+ * S'ajoutait le poids : la carte d'identité porte déjà trois états d'affiche,
+ * un niveau de titre calculé, un nom de release découpé aux séparateurs et
+ * cinq fournisseurs de fiches. Les deux blocs d'ici l'auraient menée près du
+ * double, pour un composant qui aurait alors répondu à deux questions.
+ *
+ * # Ce composant POSSÈDE son fond, et c'est délibéré
+ *
+ * `IdentityCard` porte une note expliquant qu'elle s'interdit `--fg-subtle`
+ * parce qu'elle ne sait pas sur quoi la page la pose. C'est exact, et la page
+ * la pose en réalité à même `.release-page`, qui n'a pas de fond du tout —
+ * donc sur `--bg-base`, et non sur `--bg-surface` comme cette note l'affirme.
+ * En écrivant `--bg-surface` ici, chaque paire de ce fichier devient mesurable
+ * une fois pour toutes, où que la page décide de coller le ruban.
+ */
+
+/** Une étiquette telle que l'API la sert. `color` est un hexadécimal libre. */
+interface TorrentTag {
+  id: string;
+  name: string;
+  slug: string;
+  color: string;
+}
+
+const props = withDefaults(
+  defineProps<{
+    /**
+     * Le nom de release, pour savoir ce que les pastilles disent déjà.
+     *
+     * Mesuré sur le catalogue : 72 % des tags répétaient mot pour mot une
+     * pastille, et l'essentiel du reste était le même fait sous un autre nom.
+     * Sans ce nom, tous les tags s'affichent — ne rien savoir n'est pas une
+     * raison de cacher.
+     */
+    releaseName?: string | null;
+    /** L'uploadeur, ou `null` — masqué OU compte supprimé, voir ci-dessous. */
+    uploader?: { id: string; username: string } | null;
+    /**
+     * Ce qui sépare les deux formes d'absence.
+     *
+     * Un uploadeur MASQUÉ et un compte SUPPRIMÉ arrivent tous deux avec
+     * `uploader: null` ; seul ce drapeau les distingue, et dire « compte
+     * supprimé » d'un membre encore présent serait faux.
+     */
+    uploaderAnonymous?: boolean;
+    tags?: TorrentTag[] | null;
+    /**
+     * Sans sa coquille : posé dans la bande d'identité de la fiche, au bout
+     * de la ligne des pastilles, il se lit comme une mention et non comme un
+     * panneau de plus.
+     */
+    bare?: boolean;
+  }>(),
+  { releaseName: null, uploader: null, uploaderAnonymous: false, tags: null, bare: false },
+);
+
+/*
+ * Seulement ceux qu'aucune pastille ne dit déjà.
+ *
+ * La rangée cesse d'être un doublon permanent pour devenir une rangée
+ * d'EXCEPTION : elle ne se rend que quand elle a quelque chose à ajouter — un
+ * tag posé à la main par l'uploadeur (`anime`, `drm-free`), pas la résolution
+ * qui s'affiche en couleur trente pixels plus haut.
+ */
+const tags = computed(() => tagsBeyondChips(props.releaseName, props.tags));
+
+/**
+ * La seule couleur de cette page qui vient légitimement de la base.
+ *
+ * L'exploitant choisit une teinte par étiquette (console d'admin, « choisis
+ * une teinte par tag »), donc elle arrive en hexadécimal et ne peut pas être
+ * un jeton. La question est alors : le texte reste-t-il lisible dessus ?
+ *
+ * La réponse tient dans la stratégie, pas dans un calcul. La teinte ne va
+ * qu'au FOND, à ~10 % d'alpha, et à la bordure à ~40 % ; le texte est forcé
+ * sur `--fg-default`. Le fond composité reste donc à un cheveu de celui de la
+ * carte, et le contraste ne dépend presque plus de la couleur choisie —
+ * mesuré sur `--bg-surface`, le pire cas est un tag blanc pur en thème sombre
+ * à 13,39:1, et tous les autres essais (noir, rouge, jaune, bleu) tombent
+ * entre 15,7 et 19,8:1. Aucune teinte ne peut faire passer ce texte sous le
+ * seuil, ce qui est exactement ce qu'on veut d'une valeur qu'on ne contrôle
+ * pas.
+ *
+ * Une couleur illisible ou absente retombe sur du neutre plutôt que de
+ * produire un `background-color: #undefined1a` que le navigateur ignore en
+ * silence.
+ */
+function tagStyle(tag: TorrentTag) {
+  const hex = (tag.color || '').replace('#', '');
+  if (!/^[0-9a-f]{6}$/i.test(hex)) {
+    return {
+      backgroundColor: 'rgb(var(--bg-inset))',
+      borderColor: 'rgb(var(--line-default))',
+    };
+  }
+  return { backgroundColor: `#${hex}1a`, borderColor: `#${hex}66` };
+}
+
+/** La pastille de teinte pure — seule chose qui porte VRAIMENT la couleur. */
+function dotStyle(tag: TorrentTag) {
+  const hex = (tag.color || '').replace('#', '');
+  if (!/^[0-9a-f]{6}$/i.test(hex)) return { backgroundColor: 'rgb(var(--fg-muted))' };
+  return { backgroundColor: `#${hex}` };
+}
+</script>
+
+<template>
+  <dl class="prov" :class="{ 'prov--bare': bare }">
+    <div class="prov-cell">
+      <dt class="prov-key">{{ $t('torrents.detail.uploadedBy') }}</dt>
+      <dd class="prov-val">
+        <NuxtLink
+          v-if="uploader"
+          :to="`/users/${uploader.id}`"
+          class="prov-user"
+        >
+          <Icon name="ph:user-bold" class="prov-user-icon" aria-hidden="true" />
+          @{{ uploader.username }}
+        </NuxtLink>
+        <!-- Les DEUX formes d'absence, jamais confondues : voir le prop
+             `uploaderAnonymous`. -->
+        <span
+          v-else-if="uploaderAnonymous"
+          class="prov-user prov-user--absent"
+          :title="$t('torrents.detail.uploaderAnonymousTooltip')"
+        >
+          <Icon name="ph:user-bold" class="prov-user-icon" aria-hidden="true" />
+          {{ $t('torrents.detail.uploaderAnonymous') }}
+        </span>
+        <span
+          v-else
+          class="prov-user prov-user--absent"
+          :title="$t('torrents.detail.uploaderGoneTooltip')"
+        >
+          <Icon name="ph:user-minus-bold" class="prov-user-icon" aria-hidden="true" />
+          {{ $t('torrents.detail.uploaderGone') }}
+        </span>
+      </dd>
+    </div>
+
+    <div v-if="tags.length" class="prov-cell prov-cell--tags">
+      <dt class="prov-key">{{ $t('torrents.detail.provenance.tags') }}</dt>
+      <dd class="prov-val">
+        <ul class="prov-tags">
+          <li v-for="tag in tags" :key="tag.id">
+            <NuxtLink
+              :to="`/torrents?tag=${encodeURIComponent(tag.slug)}`"
+              class="prov-tag"
+              :style="tagStyle(tag)"
+              :title="$t('torrents.detail.provenance.tagLink', { name: tag.name })"
+            >
+              <span class="prov-tag-dot" :style="dotStyle(tag)" aria-hidden="true" />
+              {{ tag.name }}
+            </NuxtLink>
+          </li>
+        </ul>
+      </dd>
+    </div>
+  </dl>
+</template>
+
+<style scoped>
+.prov {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 0.5rem 1.4rem;
+  margin: 0;
+  padding: 0.55rem 0.85rem;
+  background-color: rgb(var(--bg-surface));
+  border: 1px solid rgb(var(--line-default));
+  border-radius: var(--radius-md);
+}
+
+.prov-cell {
+  display: flex;
+  /* La valeur ne passe sous sa clé que si elle ne tient VRAIMENT pas. C'est
+     au contenu de décider, pas à la largeur de la fenêtre : « @founder » fait
+     un mot, et il tenait à côté de « UPLOADÉ PAR » sur toutes les largeurs où
+     un point de rupture le renvoyait quand même à la ligne. */
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 0.5rem;
+  min-width: 0;
+}
+/* Les étiquettes peuvent être nombreuses : elles prennent la place restante
+   et passent à la ligne, alors que l'uploadeur tient toujours sur un mot. */
+.prov-cell--tags {
+  flex: 1 1 14rem;
+}
+/*
+ * La base à ZÉRO, et c'est tout l'enjeu de ce bloc.
+ *
+ * Une cellule qui enveloppe décide de passer à la ligne d'après la taille
+ * HYPOTHÉTIQUE de ses éléments, pas d'après ce à quoi ils pourraient se
+ * réduire. Avec une base automatique, la liste de pastilles se présente à sa
+ * largeur MAXIMALE — toutes bout à bout — donc elle ne tient pas à côté de
+ * « TAGS » et bascule sous lui. Elle repart alors du bord GAUCHE DE LA
+ * CELLULE, c'est-à-dire sous le mot « TAGS » lui-même, en laissant le vide à
+ * sa gauche, sous le pseudonyme. C'est le décalage qu'on voyait : constaté
+ * avec trois étiquettes à 501 px, reproduit avec douze à 768.
+ *
+ * Base zéro : la liste ne réclame plus rien, ne provoque donc aucun retour à
+ * la ligne, prend la place restante et enveloppe À L'INTÉRIEUR. Le libellé
+ * reste en regard de la première ligne de pastilles, et les suivantes
+ * s'alignent dessous — un retrait pendant, ce qu'une liste de définitions
+ * doit faire.
+ */
+.prov-cell--tags .prov-val {
+  flex: 1 1 0;
+  min-width: 0;
+}
+
+/* Le même petit capital mono que `.idc-relkey` dans la carte d'identité :
+   ces deux blocs se lisent comme un seul ensemble. */
+.prov-key {
+  flex-shrink: 0;
+  margin: 0;
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+}
+.prov-val {
+  margin: 0;
+  min-width: 0;
+}
+
+.prov-user {
+  /* WCAG 2.5.8 : 24 px CSS au minimum pour une cible de pointeur, et ceci
+     n'est pas un lien DANS une phrase, donc la dérogation « inline » ne
+     s'applique pas. Mesuré à 18 px avant. La hauteur seule change ; le texte
+     reste où il est. */
+  min-height: 1.5rem;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.3rem;
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  font-weight: 700;
+  text-decoration: none;
+  /* `--accent-warm-text` et non `--accent-warm` : le second est la teinte de
+     surface, le premier la variante assombrie pour du TEXTE — 8,23:1 en
+     sombre et 5,06:1 en clair sur ce fond.
+     L'ancienne page peignait ce lien en `--release-rose`, une propriété
+     qu'elle DÉFINISSAIT elle-même (`244 114 182`), comme le font encore
+     `me.vue` et `users/[id].vue`. Elle rendait donc bien du rose — mais un
+     rose en dur, hors du système de thème : l'exploitant peut repeindre 47
+     jetons et celui-là lui échappait. C'est la seule raison du changement. */
+  color: rgb(var(--accent-warm-text));
+  transition: color var(--dur-2) ease;
+}
+a.prov-user:hover {
+  color: rgb(var(--fg-strong));
+}
+.prov-user-icon {
+  font-size: 0.6875rem;
+}
+/* Ni lien ni nom : une mention d'absence. En italique et en neutre, pour
+   qu'on ne cherche pas à cliquer — le `title` porte l'explication. */
+.prov-user--absent {
+  font-style: italic;
+  font-weight: 500;
+  color: rgb(var(--fg-muted));
+  cursor: help;
+}
+
+.prov-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.25rem;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+.prov-tag {
+  /* WCAG 2.5.8 : 24 px CSS au minimum pour une cible de pointeur, et ceci
+     n'est pas un lien DANS une phrase, donc la dérogation « inline » ne
+     s'applique pas. Mesuré à 22 px avant. La hauteur seule change ; le texte
+     reste où il est. */
+  min-height: 1.5rem;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.3rem;
+  padding: 0.1rem 0.4rem;
+  font-size: 0.6875rem;
+  font-weight: 600;
+  text-decoration: none;
+  /* Forcé, et c'est tout l'intérêt : voir `tagStyle()`. Le fond et la bordure
+     portent la teinte de l'exploitant, le texte reste sur un jeton. */
+  color: rgb(var(--fg-default));
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  transition: filter var(--dur-2) ease;
+}
+.prov-tag:hover {
+  filter: brightness(1.25);
+}
+.prov-tag-dot {
+  width: 0.4rem;
+  height: 0.4rem;
+  flex-shrink: 0;
+  border-radius: 50%;
+  /* Le contour n'est pas décoratif : une teinte proche du fond fait
+     disparaître la pastille — un tag blanc mesure 1,00:1 sur la surface
+     claire — et il ne reste qu'un trou dans la ligne. Le contour lui garde
+     une forme quelle que soit la couleur choisie. */
+  box-shadow: inset 0 0 0 1px rgb(var(--line-strong));
+}
+
+@media (max-width: 767px) {
+  .prov {
+    gap: 0.45rem 1rem;
+    padding: 0.5rem 0.65rem;
+  }
+  /* Plus rien à empiler ici. La règle d'origine mettait TOUTES les cellules
+     en colonne sous 768 px, ce qui renvoyait « @donator » sous son libellé
+     avec 228 px de vide à sa droite ; la restreindre aux étiquettes ne faisait
+     que déplacer le défaut, puisque la cellule empilée continuait de partager
+     la rangée de l'uploadeur. La base zéro ci-dessus rend le point de rupture
+     inutile : le même retrait pendant fonctionne à 390 comme à 1600. */
+}
+
+.prov--bare {
+  padding: 0;
+  background: transparent;
+  border: 0;
+  border-radius: 0;
+  gap: 0.4rem 1.1rem;
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/QualityChips.vue b/apps/web/app/components/torrent/detail/QualityChips.vue
new file mode 100644
index 00000000..a456e214
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/QualityChips.vue
@@ -0,0 +1,348 @@
+<script setup lang="ts">
+import { tagForChip } from '~/utils/chipTagOverlap';
+import type { ReleaseChips } from '~/utils/releaseChips';
+
+/**
+ * La qualité d'une release, en emplacements fixes.
+ *
+ * # Ce que ce composant ne fait pas
+ *
+ * Il n'analyse rien. `utils/releaseChips.ts` sait déjà tirer la résolution, la
+ * source, le format, le codec, l'audio, le HDR et la langue d'un nom de
+ * release — et il n'avait qu'UN seul appelant, la ligne de groupe. Le même
+ * vocabulaire de tags a donc failli être réécrit ici, avec ses propres listes
+ * de priorité et sa propre idée de ce qu'est un `REMUX` ; c'est exactement
+ * ainsi que deux pages du même site finissent par nommer différemment la même
+ * release. Une seule table, deux rendus.
+ *
+ * # Emplacements, pas une liste
+ *
+ * L'ordre est figé et ne dépend pas de ce que la release contient : le HDR est
+ * au même rang sur une release qui n'a pas d'audio parsé que sur une release
+ * complète. C'est la raison d'être du module — un membre qui ne regarde que la
+ * résolution regarde toujours la même position, jamais un texte.
+ *
+ * # Couleur : une pastille à deux tons, et pourquoi celui-là
+ *
+ * La version d'avant portait la teinte sur le TEXTE de la valeur — trois
+ * pastilles colorées sur huit, et deux d'entre elles seulement dans un thème.
+ * Le recensement de la page l'a chiffré : 82 % des instances d'élément
+ * colorées de la fiche étaient en gris pur.
+ *
+ * Le motif est donc inversé, avec la mesure qui manquait. Ce qui échoue, ce
+ * n'est pas « un fond teinté », c'est **un fond teinté sous un texte de la même
+ * famille** : `--accent-warm-text` sur un voile d'or donne 4,13:1 en thème
+ * clair. Une encre NEUTRE sur ce même voile ne descend jamais :
+ * `--fg-muted` sur un voile à 16 % de n'importe laquelle des huit teintes, sur
+ * n'importe lequel des trois fonds de carte, dans les deux thèmes, tient
+ * **4,84:1** au pire ; `--fg-strong` tient 12,52:1.
+ *
+ * D'où : la clé porte le voile de la teinte, la valeur reste sur le fond neutre
+ * en encre pleine — et les huit emplacements deviennent huit couleurs au lieu
+ * de trois. La valeur GAGNE du contraste au passage (`--fg-strong` au lieu de
+ * `--accent-warm-text`, 21:1 au lieu de 5,06:1 en clair).
+ *
+ * Deux teintes sont écartées et il faut le dire : `--chart-3` et `--chart-6`
+ * tombent à 1,94:1 et 2,19:1 sur les surfaces du thème clair — sous les 3:1
+ * d'un élément non textuel. Elles sont inutilisables ici, quoi qu'elles
+ * donnent en sombre.
+ */
+const props = withDefaults(
+  defineProps<{
+    /** Le nom de release à analyser. Ignoré si `chips` est fourni. */
+    name?: string | null;
+    /**
+     * Des chips déjà analysées, quand l'appelant en tient (une ligne de
+     * groupe, un aperçu). Évite de repasser l'analyseur sur le même nom.
+     */
+    chips?: ReleaseChips | null;
+    /** Resserre les pastilles, pour la barre basse ou une ligne dense. */
+    compact?: boolean;
+    /**
+     * Les tags du torrent, pour rendre les pastilles CLIQUABLES.
+     *
+     * C'est la seule chose que la rangée de tags apportait et pas celle-ci :
+     * un lien vers le catalogue filtré. Sans tag correspondant, la pastille
+     * reste inerte — mieux vaut pas de lien qu'un lien vers un filtre qui ne
+     * trouverait rien.
+     */
+    tags?: ReadonlyArray<{ name: string; slug?: string }> | null;
+  }>(),
+  { name: null, chips: null, compact: false, tags: null },
+);
+
+const { t } = useI18n();
+
+const parsed = computed<ReleaseChips | null>(() => {
+  if (props.chips) return props.chips;
+  if (!props.name) return null;
+  return releaseChips(props.name);
+});
+
+interface Slot {
+  /** L'emplacement, pour la clé de boucle. */
+  id: string;
+  /**
+   * Le micro-libellé, DÉJÀ traduit.
+   *
+   * Traduit ici et non dans le gabarit : une clé construite —
+   * `$t('…chipKeys.' + slot.id)` — n'est trouvable par aucune recherche
+   * textuelle, donc une clé retirée du fichier de langue ne casse rien
+   * jusqu'au rendu. Écrites en clair, les sept clés se grepent.
+   */
+  label: string;
+  value: string;
+  /**
+   * L'emplacement de la clé de couleur — une teinte par NATURE de valeur, pas
+   * par valeur. La résolution est toujours or, la source toujours cyan : c'est
+   * ce qui permet de sauter à la bonne pastille sans lire le micro-libellé.
+   */
+  tone?: 'lang' | 'res' | 'src' | 'fmt' | 'codec' | 'audio' | 'hdr' | 'flag';
+}
+
+/**
+ * Les emplacements dans leur ordre d'affichage, les vides retirés.
+ *
+ * Retirés et non rendus vides : une pastille « SRC — » sur chaque release dont
+ * la source n'a pas été reconnue ajoute une colonne de bruit à la seule chose
+ * que cette bande existe pour rendre lisible.
+ */
+/*
+ * `resolveComponent` et non la chaîne `'NuxtLink'`.
+ *
+ * `<component :is="'NuxtLink'">` ne résout que les composants enregistrés
+ * LOCALEMENT : avec l'auto-import de Nuxt, la chaîne est sortie telle quelle et
+ * le navigateur a reçu `<nuxtlink to="/torrents?tag=vostfr">` — un élément
+ * inconnu, donc ni lien, ni clic, ni tabulation. Vérifié dans le DOM avant
+ * correction : `tagName === 'NUXTLINK'`.
+ */
+const NuxtLinkComponent = resolveComponent('NuxtLink');
+
+/** Le catalogue filtré sur ce tag, quand il en existe un pour cette valeur. */
+function chipHref(value: string | null): string | null {
+  const t = tagForChip(value, props.tags);
+  return t?.slug ? `/torrents?tag=${encodeURIComponent(t.slug)}` : null;
+}
+
+const slots = computed<Slot[]>(() => {
+  const c = parsed.value;
+  if (!c) return [];
+  const out: Slot[] = [];
+  if (c.language) {
+    out.push({
+      id: 'language',
+      label: t('torrents.detail.chipKeys.language'),
+      value: c.language,
+      tone: 'lang',
+    });
+  }
+  if (c.resolution) {
+    out.push({
+      id: 'resolution',
+      label: t('torrents.detail.chipKeys.resolution'),
+      value: c.resolution,
+      tone: 'res',
+    });
+  }
+  if (c.source) {
+    out.push({
+      id: 'source',
+      label: t('torrents.detail.chipKeys.source'),
+      value: c.source,
+      tone: 'src',
+    });
+  }
+  if (c.format) {
+    out.push({
+      id: 'format',
+      label: t('torrents.detail.chipKeys.format'),
+      value: c.format,
+      tone: 'fmt',
+    });
+  }
+  if (c.codec) {
+    out.push({
+      id: 'codec',
+      label: t('torrents.detail.chipKeys.codec'),
+      value: c.codec,
+      tone: 'codec',
+    });
+  }
+  if (c.audio) {
+    out.push({
+      id: 'audio',
+      label: t('torrents.detail.chipKeys.audio'),
+      value: c.audio,
+      tone: 'audio',
+    });
+  }
+  if (c.hdr) {
+    out.push({
+      id: 'hdr',
+      label: t('torrents.detail.chipKeys.hdr'),
+      value: c.hdr,
+      tone: 'hdr',
+    });
+  }
+  if (c.platform) {
+    out.push({
+      id: 'platform',
+      label: t('torrents.detail.chipKeys.platform'),
+      value: c.platform,
+      tone: 'src',
+    });
+  }
+  for (const flag of c.flags) {
+    out.push({
+      id: `flag:${flag}`,
+      label: t('torrents.detail.chipKeys.flag'),
+      value: flag,
+      tone: 'flag',
+    });
+  }
+  return out;
+});
+
+const label = computed(() => t('torrents.detail.quality.label'));
+</script>
+
+<template>
+  <!--
+    Une liste, pas une rangée de `<span>`. Chaque pastille est un couple
+    « nature : valeur », et c'est ce couple qu'un lecteur d'écran doit
+    annoncer — « source, WEB-DL » plutôt que « WEB-DL » seul, qui ne dit pas
+    de quoi c'est la valeur.
+  -->
+  <ul
+    v-if="slots.length"
+    class="qc"
+    :class="{ 'qc--compact': compact }"
+    :aria-label="label"
+  >
+    <li v-for="slot in slots" :key="slot.id" class="qc-item" :data-slot="slot.id">
+      <component
+        :is="chipHref(slot.value) ? NuxtLinkComponent : 'span'"
+        :to="chipHref(slot.value) || undefined"
+        class="qc-chip"
+        :class="[
+          slot.tone ? `qc-chip--${slot.tone}` : null,
+          chipHref(slot.value) ? 'qc-chip--link' : null,
+        ]"
+      >
+        <span class="qc-k">{{ slot.label }}</span>
+        <span class="qc-v">{{ slot.value }}</span>
+      </component>
+    </li>
+  </ul>
+</template>
+
+<style scoped>
+.qc {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.25rem;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.qc-chip {
+  /* Le repli est le gris de filet : une pastille sans teinte déclarée garde
+     exactement l'apparence d'avant. */
+  --chip-tone: var(--line-strong);
+  display: inline-flex;
+  align-items: stretch;
+  overflow: hidden;
+  min-height: 1.6rem;
+  /* `rem` et jamais `px` : `--ui-scale` n'est appliqué qu'une fois, sur
+     `html { font-size }`, donc une taille en pixels rend inerte le réglage
+     d'échelle de l'exploitant. */
+  font-size: 0.6875rem;
+  font-weight: 600;
+  letter-spacing: calc(0.015em * var(--tracking-scale));
+  white-space: nowrap;
+  background-color: rgb(var(--bg-inset));
+  border: 1px solid rgb(var(--chip-tone) / 0.45);
+  border-radius: var(--radius-sm);
+  color: rgb(var(--fg-strong));
+  transition: border-color var(--dur-2) var(--ease-standard);
+}
+
+/* La clé de couleur, emplacement par emplacement. Toutes les valeurs sont
+   au-dessus des 3:1 exigés d'un élément non textuel sur les fonds de la fiche,
+   dans les DEUX thèmes — pire cas mesuré : `--accent-warm` à 3,05:1 en clair
+   sur `--bg-hover`, `--chart-4` à 3,71:1 en sombre sur `--bg-hover`. */
+.qc-chip--lang { --chip-tone: var(--online); }
+.qc-chip--res { --chip-tone: var(--accent-warm); }
+.qc-chip--src { --chip-tone: var(--info); }
+.qc-chip--fmt { --chip-tone: var(--chart-1); }
+.qc-chip--codec { --chip-tone: var(--chart-4); }
+.qc-chip--audio { --chip-tone: var(--accent-cool); }
+.qc-chip--hdr { --chip-tone: var(--warning); }
+/* Un drapeau qualifie, il n'identifie pas : contour pointillé, aucune teinte —
+   c'est ce qui l'empêche de se lire comme un neuvième emplacement. */
+.qc-chip--flag {
+  --chip-tone: var(--line-strong);
+  border-style: dashed;
+  color: rgb(var(--fg-muted));
+}
+
+.qc--compact .qc-chip {
+  min-height: 1.4rem;
+  font-size: 0.625rem;
+}
+
+/* ── La clé : la plaque teintée, encre neutre ───────────────────────────────
+   16 % de la teinte, et `--fg-muted` dessus. Voir l'en-tête : c'est la seule
+   combinaison que le contraste autorise sur les huit teintes et les deux
+   thèmes (4,84:1 au pire). Le filet de droite sépare la plaque de la valeur
+   sans ajouter de couleur. */
+.qc-k {
+  display: inline-flex;
+  align-items: center;
+  padding: 0 0.35rem;
+  background: rgb(var(--chip-tone) / 0.16);
+  border-right: 1px solid rgb(var(--chip-tone) / 0.3);
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+}
+.qc-chip--flag .qc-k {
+  /* Pas de plaque sur un drapeau : il n'a pas de nature à nommer. */
+  background: transparent;
+  border-right-style: dashed;
+}
+
+/* ── La valeur : fond neutre, encre pleine ──────────────────────────────── */
+.qc-v {
+  display: inline-flex;
+  align-items: center;
+  padding: 0 0.4rem;
+  font-variant-numeric: tabular-nums;
+}
+.qc--compact .qc-k,
+.qc--compact .qc-v {
+  padding-inline: 0.3rem;
+}
+/* Le `<li>` n'est plus la pastille : c'est son enveloppe, parce que la
+   pastille est tantôt un lien, tantôt un `<span>`. */
+.qc-item {
+  display: flex;
+}
+/* Une pastille cliquable le montre : elle réagit, et elle est plus haute que
+   les 24 px de WCAG 2.5.8 puisqu'elle devient une cible de pointeur. */
+.qc-chip--link {
+  cursor: pointer;
+  min-height: 1.5rem;
+  transition:
+    border-color var(--dur-2) var(--ease-standard),
+    transform var(--dur-2) var(--ease-standard);
+}
+.qc-chip--link:hover {
+  border-color: rgb(var(--accent));
+  transform: translateY(-1px);
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/RelatedReleases.vue b/apps/web/app/components/torrent/detail/RelatedReleases.vue
new file mode 100644
index 00000000..7d8fccb8
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/RelatedReleases.vue
@@ -0,0 +1,531 @@
+<script setup lang="ts">
+/**
+ * « Qu'est-ce que c'est d'autre ? » — une section, trois provenances.
+ *
+ * # Pourquoi une seule composante
+ *
+ * La page portait TROIS sections quasi identiques : les cross-seeds locaux
+ * (l. 546), les releases remplacées (l. 591) et les cross-seeds fédérés
+ * (l. 630). Elles partageaient déjà la même famille CSS `.cross-*` — un
+ * commentaire du gabarit l'assumait, « reuses their markup so a reader scanning
+ * the page meets one list format, not three » — mais en trois copies du
+ * gabarit, donc trois occasions de dériver. Elles répondent à la même question
+ * du lecteur, elles n'ont plus qu'un rendu.
+ *
+ * Le `variant` change quatre choses et rien d'autre : le titre, la note, l'icône
+ * de ligne, et les métadonnées que la ligne a à dire. La géométrie est commune,
+ * ce qui est précisément ce qu'on veut : la couleur sémantique dans des
+ * conteneurs identiques se lit à la position.
+ *
+ * # Deux classes qui n'existaient pas
+ *
+ * `.cross-meta-size` et `.cross-meta-age` étaient posées dans le gabarit et
+ * stylées NULLE PART — elles héritaient de `.cross-meta` et ne servaient à
+ * rien. C'était visible : la taille et l'âge sortaient dans la même graisse et
+ * la même couleur que le reste, alors que la taille est la seule colonne que
+ * l'œil compare d'une ligne à l'autre. Elles ont maintenant un sens (chiffres
+ * tabulaires pour la taille, encre discrète pour l'âge).
+ *
+ * # Deux champs que l'API renvoyait et que la page jetait
+ *
+ * `moderationStatus` et `uploader` arrivaient dans `/cross-seeds` et n'étaient
+ * jamais affichés. Le premier explique pourquoi un cross-seed proposé peut être
+ * invisible dans le catalogue ; le second dit à qui parler quand deux releases
+ * du même contenu divergent. Les deux comptent avant de cliquer.
+ */
+import { formatAge, formatSize } from '~/utils/format';
+import type { CrossSeedItem, FederatedCrossSeedItem } from '~/composables/useTorrentDetail';
+import TorrentModerationBadge from '~/components/torrent/TorrentModerationBadge.vue';
+
+/** Ce que `/supersessions` renvoie dans `supersedes` — un type local, faute d'un exporté. */
+export interface SupersededItem {
+  infoHash: string;
+  name: string;
+  size: number;
+  supersedeReason: string | null;
+}
+
+type RelatedItem = CrossSeedItem | SupersededItem | FederatedCrossSeedItem;
+type ModerationStatus = 'pending' | 'accepted' | 'changes_requested' | 'rejected';
+
+const props = withDefaults(
+  defineProps<{
+    /**
+     * D'où viennent ces releases :
+     * - `cross` — le même contenu, ici, sous un autre `.torrent` ;
+     * - `supersedes` — les releases que celle-ci remplace ;
+     * - `federated` — le même contenu chez un partenaire.
+     */
+    variant: 'cross' | 'supersedes' | 'federated';
+    /** Tel que le composable le renvoie ; la normalisation est interne. */
+    items: RelatedItem[];
+    /** `federated` seulement : les seeders du maillage, quand il y en a. */
+    meshSeeders?: number | null;
+  }>(),
+  { meshSeeders: null },
+);
+
+const { locale } = useI18n();
+
+/* ── Ce que le variant décide ──────────────────────────────────────────────── */
+
+const title = computed(() => {
+  switch (props.variant) {
+    case 'cross':
+      return 'torrents.detail.sections.crossSeeds';
+    case 'supersedes':
+      return 'torrents.detail.supersede.title';
+    default:
+      return 'torrents.detail.sections.crossSeedsFederated';
+  }
+});
+
+const note = computed(() => {
+  switch (props.variant) {
+    case 'cross':
+      return 'torrents.detail.crossSeedNote';
+    case 'supersedes':
+      return 'torrents.detail.supersede.replaces';
+    default:
+      return 'torrents.detail.crossSeedFederatedNote';
+  }
+});
+
+const rowIcon = computed(() => {
+  switch (props.variant) {
+    case 'cross':
+      return 'ph:arrows-left-right-bold';
+    case 'supersedes':
+      return 'ph:arrow-bend-left-down-bold';
+    default:
+      return 'ph:broadcast-bold';
+  }
+});
+
+const sectionIcon = computed(() =>
+  props.variant === 'federated' ? 'ph:broadcast-bold' : 'ph:arrows-left-right-bold',
+);
+
+/* ── Une ligne, quelle que soit la provenance ─────────────────────────────── */
+
+interface Row {
+  key: string;
+  to: string;
+  name: string;
+  size: number;
+  category: string | null;
+  createdAt: string | null;
+  uploader: { id: string; username: string } | null;
+  moderationStatus: ModerationStatus | null;
+  peerName: string | null;
+  seeders: number | null;
+  matchType: string | null;
+  reason: string | null;
+}
+
+/**
+ * Le statut de modération, seulement quand il dit quelque chose.
+ *
+ * `accepted` est le cas ordinaire : l'afficher mettrait un tampon sur chaque
+ * ligne et le tampon ne voudrait plus rien dire. Une valeur inconnue est
+ * écartée plutôt que rendue — la colonne est un `text` en base.
+ */
+function moderationOf(raw: unknown): ModerationStatus | null {
+  return raw === 'pending' || raw === 'changes_requested' || raw === 'rejected'
+    ? raw
+    : null;
+}
+
+const rows = computed<Row[]>(() =>
+  props.items.map((raw) => {
+    const it = raw as Partial<CrossSeedItem & SupersededItem & FederatedCrossSeedItem>;
+    const federated = props.variant === 'federated';
+    return {
+      key: it.id ?? it.infoHash ?? it.name ?? '',
+      // Un partenaire se lit sur notre miroir (`/federated/{id}`), jamais sur
+      // son URL brute : c'est la page qui applique le masque local.
+      to: federated ? `/federated/${it.id}` : `/torrents/${it.infoHash}`,
+      name: it.name ?? '',
+      size: it.size ?? 0,
+      category: it.category?.name ?? null,
+      createdAt: it.createdAt ?? null,
+      uploader: it.uploader ?? null,
+      moderationStatus: moderationOf(it.moderationStatus),
+      peerName: it.peerName ?? null,
+      seeders: typeof it.seeders === 'number' ? it.seeders : null,
+      matchType: it.matchType ?? null,
+      reason: it.supersedeReason ?? null,
+    };
+  }),
+);
+
+/*
+ * Le compte est celui des lignes RENDUES, jamais un `total` d'API. Les deux
+ * diffèrent dès qu'une réponse est tronquée, et une pastille qui annonce 50
+ * au-dessus de 10 lignes envoie chercher les 40 autres.
+ */
+const count = computed(() => rows.value.length);
+
+/** `Intl` plutôt que `String(n)` : un compteur de seeders s'écrit 1 234 en fr. */
+const nf = computed(() => new Intl.NumberFormat(locale.value));
+</script>
+
+<template>
+  <section v-if="rows.length" class="related" :class="`related--${variant}`">
+    <SectionHead :title="$t(title)" :count="count" :icon="sectionIcon" />
+
+    <p class="related-note">
+      <Icon name="ph:info-bold" class="related-note-icon" aria-hidden="true" />
+      <span>
+        {{ $t(note) }}
+        <!-- Conteneur neutre plus un point coloré, et non un texte teinté sur
+             un voile de sa propre couleur : cette dernière paire tombe sous
+             4,5:1 en thème clair. -->
+        <span v-if="variant === 'federated' && meshSeeders" class="related-mesh">
+          <span class="related-mesh-dot" aria-hidden="true" />
+          {{ $t('torrents.detail.crossSeedMeshSeeders', { n: meshSeeders }) }}
+        </span>
+      </span>
+    </p>
+
+    <ul class="related-list">
+      <li v-for="row in rows" :key="row.key" class="related-item">
+        <NuxtLink :to="row.to" class="related-link">
+          <Icon :name="rowIcon" class="related-icon" aria-hidden="true" />
+
+          <span class="related-body">
+            <span class="related-name">{{ row.name }}</span>
+
+            <span class="related-meta">
+              <!-- Chez un partenaire, l'instance remplace la catégorie : c'est
+                   la première chose à savoir avant de cliquer. -->
+              <span v-if="row.peerName" class="related-meta-peer">{{ row.peerName }}</span>
+              <template v-else-if="row.category">
+                <span class="related-meta-cat">{{ row.category }}</span>
+              </template>
+
+              <template v-if="row.seeders !== null">
+                <span class="related-meta-sep" aria-hidden="true">·</span>
+                <span
+                  class="related-meta-seed"
+                  :title="$t('torrents.detail.related.seedersTitle', { n: row.seeders })"
+                >
+                  <!-- Le même chevron que partout sur la fiche ; l'infobulle
+                       nomme la valeur, le mot reste pour le lecteur d'écran. -->
+                  <Icon name="ph:caret-up-fill" class="related-meta-seed-i" aria-hidden="true" />
+                  {{ nf.format(row.seeders) }}
+                  <span class="sr-only">{{ $t('torrents.detail.stats.seeders') }}</span>
+                </span>
+              </template>
+
+              <span class="related-meta-sep" aria-hidden="true">·</span>
+              <span class="related-meta-size">{{ formatSize(row.size) }}</span>
+
+              <template v-if="row.createdAt">
+                <span class="related-meta-sep" aria-hidden="true">·</span>
+                <span class="related-meta-age">{{ formatAge(row.createdAt) }}</span>
+              </template>
+
+              <!-- L'uploadeur : à qui parler quand deux releases du même
+                   contenu divergent. L'API le renvoyait déjà. -->
+              <template v-if="row.uploader">
+                <span class="related-meta-sep" aria-hidden="true">·</span>
+                <span class="related-meta-up">{{ row.uploader.username }}</span>
+              </template>
+
+              <template v-if="row.reason">
+                <span class="related-meta-sep" aria-hidden="true">·</span>
+                <span class="related-meta-reason">{{ row.reason }}</span>
+              </template>
+
+              <!-- « racine v2 », pas « vérifié » : la racine est une valeur que
+                   le partenaire publie sur ses propres octets, et rien ici ne
+                   l'a recalculée. C'est une clé de correspondance forte, et ça
+                   reste sa déclaration. -->
+              <span
+                v-if="row.matchType"
+                class="related-match"
+                :class="row.matchType === 'v2' ? 'related-match--root' : 'related-match--hint'"
+                :title="row.matchType === 'v2'
+                  ? $t('torrents.detail.crossMatchV2Title')
+                  : $t('torrents.detail.crossMatchHintTitle')"
+              >
+                <span class="related-match-dot" aria-hidden="true" />
+                {{ row.matchType === 'v2'
+                  ? $t('torrents.detail.crossMatchVerified')
+                  : $t('torrents.detail.crossMatchHint') }}
+              </span>
+            </span>
+          </span>
+
+          <!-- Pourquoi un cross-seed proposé peut rester introuvable dans le
+               catalogue. `moderationStatus` arrivait dans la charge utile et la
+               page le jetait. -->
+          <TorrentModerationBadge
+            v-if="row.moderationStatus"
+            :status="row.moderationStatus"
+            size="sm"
+            class="related-mod"
+          />
+
+          <Icon name="ph:arrow-right-bold" class="related-arrow" aria-hidden="true" />
+        </NuxtLink>
+      </li>
+    </ul>
+  </section>
+</template>
+
+<style scoped>
+.related {
+  /* Une teinte par provenance, consommée par le filet de tête de ligne. Locale
+     à la composante : `--release-purple` n'est déclarée que sur la page, et une
+     composante qui l'emprunte rend gris partout ailleurs.
+
+     `--section-tone` suit la même teinte, pour que l'en-tête de section, le
+     filet et les lignes disent tous la même chose — c'est l'intérêt d'une
+     propriété héritée : une seule déclaration par variante. */
+  --related-tint: var(--chart-4);
+  --section-tone: var(--related-tint);
+}
+/* Le remplacement est un fait administratif : il prend le bleu de l'équipe. */
+.related--supersedes { --related-tint: var(--chart-1); }
+.related--federated { --related-tint: var(--info); }
+
+.related-note {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.45rem;
+  margin: 0 0 0.7rem;
+  padding: 0.45rem 0.6rem;
+  background-color: rgb(var(--related-tint) / 0.06);
+  border-left: 2px solid rgb(var(--related-tint) / 0.45);
+  border-radius: 0 var(--radius-sm) var(--radius-sm) 0;
+  font-size: 0.78125rem;
+  line-height: 1.5;
+  color: rgb(var(--fg-muted));
+}
+.related-note-icon {
+  flex: none;
+  margin-top: 0.15rem;
+  color: rgb(var(--related-tint));
+}
+
+.related-mesh {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  margin-left: 0.4rem;
+  padding: 0.05rem 0.5rem;
+  border-radius: var(--radius-pill);
+  border: 1px solid rgb(var(--line-default));
+  background: rgb(var(--bg-inset));
+  font-weight: 600;
+  color: rgb(var(--fg-default));
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+}
+.related-mesh-dot {
+  flex: none;
+  width: 0.4rem;
+  height: 0.4rem;
+  border-radius: var(--radius-pill);
+  background: rgb(var(--online));
+}
+
+.related-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0.45rem;
+}
+.related-item { display: block; }
+
+/* La ligne prend un voile de sa teinte de provenance à 6 %, sous une encre
+   entièrement NEUTRE (`--fg-strong` pour le nom, `--fg-muted` pour la méta) :
+   mesuré, `--fg-default` sur un voile à 6 % de n'importe laquelle des quatre
+   teintes décoratives donne 15,01:1 au pire en sombre et 16,96:1 en clair, et
+   `--fg-muted` 6,06:1 et 6,39:1. Le survol monte le voile à 11 % au lieu de
+   basculer sur le gris de survol : la couleur de la famille reste, elle
+   s'affirme. Les courbes viennent des jetons, `ease` nu ayant été remplacé —
+   `--ease-standard` est la courbe du site et n'était presque jamais demandée. */
+.related-link {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 0.85rem 1rem;
+  background:
+    linear-gradient(rgb(var(--related-tint) / 0.06), rgb(var(--related-tint) / 0.06)),
+    rgb(var(--bg-elevated));
+  border: 1px solid rgb(var(--related-tint) / 0.22);
+  border-left: 3px solid rgb(var(--related-tint) / 0.6);
+  border-radius: var(--radius-md);
+  text-decoration: none;
+  color: rgb(var(--fg-default));
+  transition:
+    background-color var(--dur-3) var(--ease-standard),
+    border-color var(--dur-3) var(--ease-standard),
+    transform var(--dur-4) var(--ease-emphasis);
+}
+.related-link:hover {
+  background:
+    linear-gradient(rgb(var(--related-tint) / 0.11), rgb(var(--related-tint) / 0.11)),
+    rgb(var(--bg-elevated));
+  border-color: rgb(var(--related-tint) / 0.4);
+  border-left-color: rgb(var(--related-tint));
+  transform: translateX(2px);
+}
+@media (prefers-reduced-motion: reduce) {
+  .related-link:hover {
+    transform: none;
+  }
+}
+
+/* L'icône de provenance porte la teinte — élément non textuel, donc 3:1 et
+   non 4,5:1 : la pire des quatre est `--chart-4` à 3,71:1 en sombre et
+   `--accent-warm` à 3,05:1 en clair. */
+.related-icon {
+  flex: none;
+  font-size: 1.05rem;
+  color: rgb(var(--related-tint));
+}
+
+.related-body {
+  flex: 1 1 auto;
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+}
+
+.related-name {
+  flex: 1 1 auto;
+  min-width: 0;
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  font-weight: 600;
+  color: rgb(var(--fg-strong));
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.related-link:hover .related-name { color: rgb(var(--fg-strong)); }
+
+.related-meta {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  flex: none;
+  font-family: var(--font-mono);
+  font-size: var(--label-md, 0.625rem);
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+  font-variant-numeric: tabular-nums;
+}
+.related-meta-sep { opacity: 0.45; }
+.related-meta-cat,
+.related-meta-peer {
+  font-weight: 700;
+  color: rgb(var(--fg-default));
+}
+
+/* Les deux classes que le gabarit posait et que la feuille ne connaissait pas.
+   La taille est la seule valeur que l'œil compare d'une ligne à l'autre : elle
+   prend les chiffres tabulaires et l'encre pleine. L'âge, jamais comparé, passe
+   en encre discrète — et reste sur `--fg-muted`, pas sur `--fg-subtle`, qui ne
+   tient pas 4,5:1 sur le fond de survol en thème sombre. */
+.related-meta-size {
+  font-weight: 700;
+  color: rgb(var(--fg-default));
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+}
+.related-meta-age {
+  color: rgb(var(--fg-muted));
+  white-space: nowrap;
+}
+.related-meta-up {
+  color: rgb(var(--fg-muted));
+  text-transform: none;
+  letter-spacing: normal;
+  max-width: 9rem;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.related-meta-reason {
+  color: rgb(var(--fg-muted));
+  text-transform: none;
+  letter-spacing: normal;
+}
+
+.related-meta-seed {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  font-weight: 700;
+  color: rgb(var(--fg-default));
+  white-space: nowrap;
+}
+.related-meta-seed-i {
+  font-size: 0.6rem;
+  margin-right: 0.1rem;
+  color: rgb(var(--online));
+}
+
+.related-match {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.3rem;
+  padding: 0.05rem 0.4rem;
+  border-radius: var(--radius-pill);
+  border: 1px solid rgb(var(--line-default));
+  background: rgb(var(--bg-inset));
+  font-weight: 600;
+  color: rgb(var(--fg-default));
+  white-space: nowrap;
+}
+.related-match-dot {
+  width: 0.35rem;
+  height: 0.35rem;
+  border-radius: var(--radius-pill);
+  background: rgb(var(--fg-faint));
+}
+.related-match--root .related-match-dot { background: rgb(var(--online)); }
+.related-match--hint .related-match-dot { background: rgb(var(--fg-faint)); }
+
+.related-mod { flex: none; }
+
+.related-arrow {
+  flex: none;
+  font-size: 0.85rem;
+  color: rgb(var(--fg-muted));
+  transition:
+    transform var(--dur-3) var(--ease-standard),
+    color var(--dur-3) var(--ease-standard);
+}
+.related-link:hover .related-arrow {
+  color: rgb(var(--related-tint));
+  transform: translateX(2px);
+}
+
+@media (max-width: 900px) {
+  .related-body {
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 0.35rem;
+  }
+  .related-name { white-space: normal; overflow-wrap: anywhere; }
+  .related-meta { flex-wrap: wrap; }
+}
+@media (max-width: 720px) {
+  .related-link {
+    flex-wrap: wrap;
+    align-items: flex-start;
+    padding: 0.7rem 0.85rem;
+  }
+  .related-arrow { display: none; }
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/SeedObligationCard.vue b/apps/web/app/components/torrent/detail/SeedObligationCard.vue
new file mode 100644
index 00000000..643fe6d8
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/SeedObligationCard.vue
@@ -0,0 +1,318 @@
+<script setup lang="ts">
+import type { SeedObligation } from '~/composables/useTorrentDetail';
+
+/**
+ * Ce que le membre doit encore à CETTE release.
+ *
+ * # La donnée existait et n'atteignait pas la page
+ *
+ * `/api/torrents/:hash/my-obligation` répond depuis toujours ; la page de
+ * détail ne l'appelait pas. Un membre voyait donc « seeders 47 » sans jamais
+ * voir « et il vous reste 61 h à tenir sur celle-ci » — la seule des deux
+ * informations qui le concerne personnellement, et la seule qui répond à
+ * « devrais-je la prendre ».
+ *
+ * # Une phrase, pas un ratio
+ *
+ * « 0,15 » ne dit rien. « 11 h / 72 h » demande une soustraction. « Il reste
+ * 61 h avant de vous libérer » dit exactement ce qu'il y a à faire, et c'est
+ * la formulation que porte ce composant. La jauge et les chiffres restent —
+ * pour l'œil qui vérifie — mais ils viennent APRÈS la phrase, jamais à sa
+ * place.
+ *
+ * # Couleur
+ *
+ * L'état colore le TEXTE et la jauge sur un fond neutre. Le motif inverse — un
+ * voile de la couleur d'état en fond — fait tomber la paire sous 4,5:1 en
+ * thème clair, et l'état est précisément ce qu'il ne faut pas rendre illisible.
+ */
+const props = withDefaults(
+  defineProps<{
+    /**
+     * L'obligation, telle que la renvoie `useTorrentDetail`. `null` quand le
+     * visiteur n'est pas connecté — le composant ne rend alors rien.
+     */
+    obligation?: SeedObligation | null;
+    /** Ajoute le cadre de carte, pour un usage hors de `DecisionCard`. */
+    boxed?: boolean;
+  }>(),
+  { obligation: null, boxed: false },
+);
+
+const { t, locale } = useI18n();
+
+const view = computed(() => obligationView(props.obligation));
+
+/**
+ * Quand l'état change pendant que la carte est affichée — « pas encore
+ * téléchargée » qui devient « en cours » une seconde après le clic — un
+ * balayage de la teinte traverse la carte : c'est la conséquence du geste qui
+ * descend dans la page. Jamais au premier rendu.
+ */
+const changed = ref(false);
+let changedTimer: ReturnType<typeof setTimeout> | null = null;
+watch(() => view.value?.state, (next, prev) => {
+  if (prev === undefined || next === prev) return;
+  changed.value = false;
+  requestAnimationFrame(() => { changed.value = true; });
+  if (changedTimer) clearTimeout(changedTimer);
+  changedTimer = setTimeout(() => (changed.value = false), 800);
+});
+onBeforeUnmount(() => { if (changedTimer) clearTimeout(changedTimer); });
+
+const stateLabel = computed(() => {
+  switch (view.value?.state) {
+    case 'exempt':
+      return t('torrents.detail.obligation.state.exempt');
+    case 'pending':
+      return t('torrents.detail.obligation.state.pending');
+    case 'hnr':
+      return t('torrents.detail.obligation.state.hnr');
+    case 'met':
+      return t('torrents.detail.obligation.state.met');
+    default:
+      return t('torrents.detail.obligation.state.running');
+  }
+});
+
+/** La phrase. C'est elle qui porte l'information, pas la jauge. */
+const note = computed(() => {
+  const v = view.value;
+  if (!v) return '';
+  const remaining = formatDurationSeconds(v.remaining, locale.value);
+  const required = formatDurationSeconds(v.requiredSeedTime, locale.value);
+  switch (v.state) {
+    case 'exempt':
+      return t('torrents.detail.obligation.exemptNote');
+    case 'pending':
+      return t('torrents.detail.obligation.pendingNote', { time: required });
+    case 'hnr':
+      return t('torrents.detail.obligation.hnrNote', { time: remaining });
+    case 'met':
+      return t('torrents.detail.obligation.metNote');
+    default:
+      return t('torrents.detail.obligation.remaining', { time: remaining });
+  }
+});
+
+const doneText = computed(() =>
+  view.value ? formatDurationSeconds(view.value.seedTime, locale.value) : '',
+);
+const requiredText = computed(() =>
+  view.value ? formatDurationSeconds(view.value.requiredSeedTime, locale.value) : '',
+);
+const percentText = computed(() =>
+  view.value
+    ? (view.value.percent / 100).toLocaleString(locale.value, {
+        style: 'percent',
+        maximumFractionDigits: 0,
+      })
+    : '',
+);
+
+/**
+ * La jauge n'existe que quand il y a une progression à montrer.
+ *
+ * Un membre exempté n'a pas de compteur, et un membre qui n'a pas pris la
+ * release a un compteur à zéro qui ne veut pas dire « en retard » — dessiner
+ * une barre vide dirait exactement le contraire de la phrase au-dessus.
+ */
+const showMeter = computed(
+  () => view.value !== null && view.value.state !== 'exempt' && view.value.state !== 'pending',
+);
+</script>
+
+<template>
+  <div
+    v-if="view"
+    class="sob"
+    :class="[`sob--${view.state}`, { 'card sob--boxed': boxed, 'sob--changed': changed }]"
+  >
+    <div class="sob-head">
+      <span class="eyebrow-mono sob-key">{{ $t('torrents.detail.obligation.title') }}</span>
+      <Transition name="sob-t" mode="out-in">
+        <span :key="view.state" class="sob-state">{{ stateLabel }}</span>
+      </Transition>
+    </div>
+
+    <div
+      v-if="showMeter"
+      class="sob-meter"
+      role="progressbar"
+      :aria-label="$t('torrents.detail.obligation.meterLabel')"
+      aria-valuemin="0"
+      aria-valuemax="100"
+      :aria-valuenow="view.percent"
+      :aria-valuetext="
+        $t('torrents.detail.obligation.progress', {
+          done: doneText,
+          required: requiredText,
+        })
+      "
+    >
+      <span class="sob-fill" :style="{ width: `${view.percent}%` }" />
+    </div>
+
+    <p v-if="showMeter" class="sob-legend">
+      <span class="sob-done">{{ doneText }} · {{ percentText }}</span>
+      <span class="sob-required">{{
+        $t('torrents.detail.obligation.requiredShort', { time: requiredText })
+      }}</span>
+    </p>
+
+    <p class="sob-note">{{ note }}</p>
+  </div>
+</template>
+
+<style scoped>
+.sob {
+  display: flex;
+  flex-direction: column;
+  gap: 0.35rem;
+  /* La teinte de l'état, choisie une fois et consommée par le texte et la
+     jauge. Un `--tone` plutôt que six règles dupliquées. */
+  --tone: var(--warning);
+}
+.sob--changed {
+  background-image: linear-gradient(100deg, transparent 30%, rgb(var(--tone) / 0.18) 50%, transparent 70%);
+  background-size: 250% 100%;
+  background-repeat: no-repeat;
+  animation: sob-sweep calc(600ms * var(--motion-scale)) var(--ease-standard) both;
+}
+@keyframes sob-sweep {
+  from { background-position: 120% 0; }
+  to { background-position: -120% 0; }
+}
+.sob-t-enter-active,
+.sob-t-leave-active {
+  transition: opacity var(--dur-2) var(--ease-standard), transform var(--dur-2) var(--ease-standard);
+}
+.sob-t-enter-from { opacity: 0; transform: translateY(0.3em); }
+.sob-t-leave-to { opacity: 0; transform: translateY(-0.3em); }
+.sob--hnr {
+  --tone: var(--danger);
+}
+.sob--met,
+.sob--exempt {
+  --tone: var(--online);
+}
+.sob--pending {
+  --tone: var(--fg-muted);
+}
+
+/* Hors de `DecisionCard`, la carte porte son propre cadre — et un voile de sa
+   teinte d'état à 8 %. Les trois textes qu'elle porte sont NEUTRES ou de la
+   teinte sur fond neutre… sauf `.sob-state`, qui est de la teinte : il repasse
+   donc en encre neutre forte quand le voile est là (voir sa règle). Mesuré :
+   `--fg-default` sur un voile à 8 % des quatre teintes d'état donne 12,82:1 au
+   pire, `--fg-muted` 5,18:1. */
+.sob--boxed {
+  padding: 0.7rem 0.85rem;
+  background:
+    linear-gradient(rgb(var(--tone) / 0.08), rgb(var(--tone) / 0.08)),
+    rgb(var(--bg-surface));
+  border-left: 3px solid rgb(var(--tone));
+}
+
+.sob-head {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+}
+.sob-key {
+  /* `.eyebrow-mono` porte la casse, la graisse et l'interlettrage ; seule la
+     couleur change ici, parce que le motif a treize copies dans le dépôt et
+     qu'une quatorzième ne servirait personne. */
+  color: rgb(var(--fg-muted));
+}
+.sob-state {
+  /* Texte teinté sur fond NEUTRE : c'est la paire qui tient dans les deux
+     thèmes. Le fond teinté sous le même texte ne tient pas en clair —
+     `--online` sur un voile d'elle-même tombe à 4,08:1, `--warning` à 4,07:1.
+     D'où la ligne suivante : dès que la variante encadrée pose son voile, ce
+     texte-ci renonce à la teinte. La pastille de gauche la garde, elle n'est
+     pas du texte. */
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  font-size: 0.8125rem;
+  font-weight: 700;
+  color: rgb(var(--tone));
+}
+.sob--boxed .sob-state {
+  color: rgb(var(--fg-strong));
+}
+.sob-state::before {
+  content: '';
+  flex: none;
+  width: 0.45rem;
+  height: 0.45rem;
+  border-radius: var(--radius-pill);
+  background: rgb(var(--tone));
+  /* Un halo pour que le point se voie sur les deux thèmes sans grossir. */
+  box-shadow: 0 0 0 2px rgb(var(--tone) / 0.22);
+}
+
+/* La jauge. Elle était un rectangle plat de 8 px dans un rectangle plat ; elle
+   a maintenant un creux (l'ombre intérieure) et un remplissage qui a un haut et
+   un bas. Ce n'est pas de la décoration : une jauge de 8 px sans relief ne se
+   distingue pas d'un filet, et c'est le seul objet de la carte qu'on lit d'un
+   coup d'œil au lieu de le lire. La rampe reste dans la MÊME teinte — un
+   dégradé de deux couleurs sur une jauge fait croire à deux seuils. */
+.sob-meter {
+  height: 0.6rem;
+  background-color: rgb(var(--bg-inset));
+  border: 1px solid rgb(var(--tone) / 0.3);
+  border-radius: var(--radius-pill);
+  overflow: hidden;
+  box-shadow: inset 0 1px 2px rgb(var(--shadow-color) / calc(0.35 * var(--shadow-strength)));
+}
+.sob-fill {
+  display: block;
+  height: 100%;
+  background-image: linear-gradient(
+    to bottom,
+    rgb(var(--tone)),
+    rgb(var(--tone) / 0.78)
+  );
+  background-color: rgb(var(--tone));
+  border-radius: var(--radius-pill);
+  transition: width var(--dur-slow) var(--ease-standard);
+}
+
+.sob-legend {
+  display: flex;
+  justify-content: space-between;
+  gap: 0.75rem;
+  margin: 0;
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  font-variant-numeric: tabular-nums;
+  color: rgb(var(--fg-default));
+}
+.sob-required {
+  color: rgb(var(--fg-muted));
+}
+
+.sob-note {
+  margin: 0;
+  font-size: 0.75rem;
+  line-height: 1.5;
+  color: rgb(var(--fg-muted));
+  font-variant-numeric: tabular-nums;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .sob-fill {
+    transition: none;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .sob--changed { animation: none; background-image: none; }
+  .sob-t-enter-active,
+  .sob-t-leave-active { transition: none; }
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/StickyDock.vue b/apps/web/app/components/torrent/detail/StickyDock.vue
new file mode 100644
index 00000000..9a50ee19
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/StickyDock.vue
@@ -0,0 +1,240 @@
+<script setup lang="ts">
+import type { SeedObligation } from '~/composables/useTorrentDetail';
+
+/**
+ * La barre basse — le CTA qui reste joignable quand la page n'a pas de rail.
+ *
+ * # Le problème mesuré
+ *
+ * Sur une fenêtre de 844 px de haut, le bouton de téléchargement de la fiche
+ * dense tombe à y=835 : neuf pixels de marge. Il est donc, en pratique,
+ * sous la ligne de flottaison — un membre sur téléphone fait défiler pour
+ * trouver la seule action de la page. Les deux références font pire encore :
+ * leur CTA devient injoignable dès qu'on descend.
+ *
+ * # Un seul contrôle focalisable, à chaque largeur
+ *
+ * Cette barre n'existe QUE sous 1280 px, et `DownloadCta` en variante
+ * `primary` disparaît exactement au même seuil (`display: none`, donc hors de
+ * l'ordre de tabulation). Les deux règles sont symétriques et portées par les
+ * composants eux-mêmes, pas par la page : un lecteur d'écran ne trouve jamais
+ * deux liens « Télécharger le .torrent », à aucune largeur.
+ *
+ * # Ce qu'elle porte en plus du bouton
+ *
+ * Seeders, leechers, taille — et le temps de seed restant. Ce dernier est la
+ * raison d'être de la barre : c'est la donnée qui fait renoncer, et la
+ * cacher derrière un défilement revient à ne pas la donner.
+ *
+ * # Condition de montage
+ *
+ * `position: sticky` : la barre doit être le DERNIER enfant du conteneur
+ * défilant de la page, et aucun de ses ancêtres ne doit porter
+ * `overflow: hidden` — sinon elle se comporte en `static`, sans erreur ni
+ * avertissement. Choisie plutôt que `fixed` parce qu'elle libère le bas de la
+ * page en fin de défilement au lieu de recouvrir en permanence 4 rem de
+ * contenu.
+ */
+/** « Pris » remonte à la page, comme depuis la carte de décision : le suivi de l'obligation repart. */
+const emit = defineEmits<{ taken: [] }>();
+const props = withDefaults(
+  defineProps<{
+    hash: string;
+    size?: number | null;
+    stats?: { seeders: number; leechers: number } | null;
+    obligation?: SeedObligation | null;
+    /** Résumé de qualité, transmis au CTA. */
+    quality?: string | null;
+    freeleech?: boolean;
+  }>(),
+  {
+    size: null,
+    stats: null,
+    obligation: null,
+    quality: null,
+    freeleech: false,
+  },
+);
+
+const { locale } = useI18n();
+
+const num = (n: number) => n.toLocaleString(locale.value);
+
+const view = computed(() => obligationView(props.obligation));
+
+/**
+ * Le temps dû n'apparaît que s'il y en a un.
+ *
+ * Un membre exempté, ou qui n'a jamais pris la release, verrait « 0 h » —
+ * un chiffre qui ressemble à une dette réglée alors qu'il n'y a jamais eu de
+ * dette. Rien à dire vaut mieux qu'un zéro ambigu sur une barre de quatre
+ * chiffres.
+ */
+const owed = computed(() => {
+  const v = view.value;
+  if (!v || v.remaining <= 0) return null;
+  if (v.state !== 'running' && v.state !== 'hnr') return null;
+  return {
+    text: formatDurationSeconds(v.remaining, locale.value),
+    late: v.state === 'hnr',
+  };
+});
+
+/*
+ * L'état écrit par l'exemplaire primaire de `DownloadCta` : « le bouton
+ * principal est-il à l'écran ? ». La barre n'est là que pour le remplacer
+ * quand il n'y est plus — sinon elle répétait la même action à trente
+ * centimètres de distance.
+ */
+const ctaOnScreen = useState('torrent-cta-onscreen', () => true);
+</script>
+
+<template>
+  <section
+    class="sd"
+    :class="{ 'sd--shown': !ctaOnScreen }"
+    :aria-label="$t('torrents.detail.dock.label')"
+  >
+    <div class="sd-in">
+      <div class="sd-facts">
+        <span v-if="stats" class="sd-fact sd-fact--seed">
+          <span class="sd-v">{{ num(stats.seeders) }}</span>
+          <span class="sd-k">{{ $t('torrents.detail.dock.seed') }}</span>
+        </span>
+        <span v-if="stats" class="sd-fact sd-fact--leech">
+          <span class="sd-v">{{ num(stats.leechers) }}</span>
+          <span class="sd-k">{{ $t('torrents.detail.dock.leech') }}</span>
+        </span>
+        <span v-if="typeof size === 'number' && size > 0" class="sd-fact">
+          <span class="sd-v">{{ formatSize(size) }}</span>
+        </span>
+        <span
+          v-if="owed"
+          class="sd-fact"
+          :class="owed.late ? 'sd-fact--late' : 'sd-fact--owed'"
+        >
+          <span class="sd-v">{{ owed.text }}</span>
+          <span class="sd-k">{{ $t('torrents.detail.dock.owed') }}</span>
+        </span>
+      </div>
+
+      <!-- Doublon pour la souris : le contrôle réel est celui de la carte de
+           décision, au 8ᵉ rang de tabulation. Voir l'en-tête de `DownloadCta`. -->
+      <TorrentDetailDownloadCta
+        aria-hidden="true"
+        tabindex="-1"
+        variant="dock"
+        :hash="hash"
+        :size="size"
+        :seeders="stats?.seeders ?? null"
+        :quality="quality"
+        :freeleech="freeleech"
+        @taken="emit('taken')"
+      />
+    </div>
+  </section>
+</template>
+
+<style scoped>
+.sd {
+  display: none;
+  position: sticky;
+  bottom: 0;
+  /* 30, l'échelon « collant » de l'échelle documentée dans `main.css`
+     (collant 30, listes déroulantes 40, modales 50, notifications 60). La
+     maquette disait 50 : la barre serait alors passée AU-DESSUS du voile
+     d'une modale ouverte par-dessus la page. */
+  z-index: 30;
+  padding: 0.625rem 1rem max(0.625rem, env(safe-area-inset-bottom));
+  background-color: rgb(var(--bg-elevated) / 0.96);
+  backdrop-filter: blur(14px);
+  border-top: 1px solid rgb(var(--line-strong));
+  box-shadow: var(--shadow-popover);
+}
+
+/* Elle n'existe que quand le CTA principal est sorti de l'écran — voir
+   `DownloadCta`. Plus de seuil de largeur : le doublon ne dépendait pas de la
+   taille de l'écran mais de la position dans le défilement. */
+.sd--shown {
+  display: block;
+}
+/* À partir de 1024 px la carte de décision est ÉPINGLÉE dans la colonne de
+   droite : le bouton principal ne sort plus jamais de l'écran, et un dock en
+   bas de page ferait doublon avec lui — deux fois le même geste à l'écran. */
+@media (min-width: 1024px) {
+  .sd,
+  .sd--shown {
+    display: none;
+  }
+}
+
+.sd-in {
+  display: flex;
+  align-items: center;
+  gap: 0.875rem;
+}
+
+.sd-facts {
+  display: flex;
+  align-items: baseline;
+  flex-wrap: wrap;
+  gap: 0.5rem 0.875rem;
+  min-width: 0;
+}
+
+.sd-fact {
+  display: flex;
+  align-items: baseline;
+  gap: 0.3125rem;
+  white-space: nowrap;
+}
+
+.sd-v {
+  /* `rem` et non `px` : `--ui-scale` n'agit que sur `html { font-size }`. */
+  font-family: var(--font-mono);
+  font-size: 0.9375rem;
+  font-weight: 700;
+  line-height: 1;
+  font-variant-numeric: tabular-nums;
+  color: rgb(var(--fg-strong));
+}
+.sd-fact--seed .sd-v {
+  color: rgb(var(--online));
+}
+.sd-fact--leech .sd-v {
+  color: rgb(var(--info));
+}
+.sd-fact--owed .sd-v {
+  color: rgb(var(--warning));
+}
+.sd-fact--late .sd-v {
+  color: rgb(var(--danger));
+}
+
+.sd-k {
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  line-height: 1;
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  /* `--fg-muted` : `--fg-subtle` tombe à 3,93:1 dès qu'un fond se rapproche
+     de `--bg-hover` en thème sombre, et un voile à 96 % s'en rapproche. */
+  color: rgb(var(--fg-muted));
+}
+
+@media (max-width: 767px) {
+  .sd {
+    padding-inline: 0.65rem;
+  }
+  .sd-in {
+    flex-wrap: wrap;
+    gap: 0.5rem;
+  }
+  .sd-facts {
+    width: 100%;
+    justify-content: space-between;
+    gap: 0.5rem;
+  }
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/SupersedeForm.vue b/apps/web/app/components/torrent/detail/SupersedeForm.vue
new file mode 100644
index 00000000..328c5da7
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/SupersedeForm.vue
@@ -0,0 +1,207 @@
+<script setup lang="ts">
+/**
+ * Le pointeur de remplacement d'une release, dans les deux sens.
+ *
+ * # Deux états, jamais les deux
+ *
+ * Ou bien la release EST déjà remplacée — on le dit, et on offre de lever le
+ * marquage ; ou bien elle ne l'est pas — on demande le hash du remplaçant et
+ * une raison. Il n'y a rien à afficher entre les deux, donc rien à empiler.
+ *
+ * # Pourquoi un hash et pas un sélecteur
+ *
+ * C'est ce que le modérateur a sous les yeux : il regarde la page de la
+ * nouvelle release dans l'autre onglet. Un champ de recherche l'obligerait à
+ * retrouver par le nom ce qu'il tient déjà par l'identifiant.
+ *
+ * Marquer ne retire rien : l'ancienne reste téléchargeable et garde son swarm.
+ * Ce qui change, c'est que les deux pages disent laquelle est la courante.
+ *
+ * # Le libellé
+ *
+ * Les deux champs restent ENVELOPPÉS dans leur `<label>` — c'est ce qui leur
+ * donne leur nom accessible, et `test/formControlNames.test.ts` casse la
+ * construction si l'un d'eux en sort sans `for`/`id` apparié.
+ */
+const props = withDefaults(
+  defineProps<{
+    /** Le hash, pour `PUT|DELETE /api/mod/torrents/:hash/supersede`. */
+    hash: string;
+    /** Ce qui remplace cette release, quand quelque chose la remplace. */
+    supersededBy?: { name?: string | null } | null;
+  }>(),
+  { supersededBy: null },
+);
+
+const emit = defineEmits<{
+  /** Une écriture a abouti : la page peut recharger les supersessions. */
+  (e: 'changed'): void;
+}>();
+
+const { t } = useI18n();
+const notifications = useNotificationStore();
+
+const form = reactive({ hash: '', reason: '' });
+const busy = ref(false);
+
+/** Un infohash SHA-1, c'est 40 caractères. En deçà, le bouton reste inerte. */
+const HASH_LENGTH = 40;
+
+async function save() {
+  busy.value = true;
+  try {
+    await $fetch(`/api/mod/torrents/${props.hash}/supersede`, {
+      method: 'PUT',
+      body: {
+        supersededById: form.hash.trim().toLowerCase(),
+        reason: form.reason.trim() || undefined,
+      },
+    });
+    form.hash = '';
+    form.reason = '';
+    emit('changed');
+    notifications.success(t('torrents.detail.supersede.saved'));
+  } catch (err: unknown) {
+    const e = err as { data?: { message?: string }; message?: string };
+    notifications.error(
+      e?.data?.message || e?.message || t('torrents.detail.supersede.failed'),
+    );
+  } finally {
+    busy.value = false;
+  }
+}
+
+async function clear() {
+  busy.value = true;
+  try {
+    await $fetch(`/api/mod/torrents/${props.hash}/supersede`, { method: 'DELETE' });
+    emit('changed');
+    notifications.success(t('torrents.detail.supersede.cleared'));
+  } catch (err: unknown) {
+    const e = err as { data?: { message?: string }; message?: string };
+    notifications.error(
+      e?.data?.message || e?.message || t('torrents.detail.supersede.failed'),
+    );
+  } finally {
+    busy.value = false;
+  }
+}
+</script>
+
+<template>
+  <section class="section">
+    <SectionHead
+      :title="$t('torrents.detail.supersede.staffTitle')"
+      icon="ph:arrow-bend-right-up"
+    />
+
+    <p class="supersede-lede">{{ $t('torrents.detail.supersede.staffLede') }}</p>
+
+    <!-- Déjà remplacée : il n'y a plus qu'une chose à faire, la lever. -->
+    <div v-if="supersededBy" class="supersede-actions">
+      <p class="supersede-lede supersede-lede--inline">
+        {{ $t('torrents.detail.supersede.currently', { name: supersededBy.name ?? '' }) }}
+      </p>
+      <button type="button" class="btn-ghost" :disabled="busy" @click="clear">
+        {{ $t('torrents.detail.supersede.clear') }}
+      </button>
+    </div>
+
+    <div v-else class="supersede-grid">
+      <label class="supersede-field supersede-field--hash">
+        <span class="field-label">{{ $t('torrents.detail.supersede.hashLabel') }}</span>
+        <input
+          v-model="form.hash"
+          type="text"
+          class="input"
+          autocomplete="off"
+          spellcheck="false"
+          :placeholder="$t('torrents.detail.supersede.hashPlaceholder')"
+        />
+      </label>
+      <label class="supersede-field supersede-field--reason">
+        <span class="field-label">{{ $t('torrents.detail.supersede.reasonLabel') }}</span>
+        <input v-model="form.reason" type="text" class="input" maxlength="500" />
+      </label>
+      <button
+        type="button"
+        class="btn btn-secondary"
+        :disabled="busy || form.hash.length !== HASH_LENGTH"
+        @click="save"
+      >
+        <Icon
+          :name="busy ? 'ph:circle-notch' : 'ph:arrow-bend-right-up-bold'"
+          :class="{ 'animate-spin': busy }"
+        />
+        {{ $t('torrents.detail.supersede.mark') }}
+      </button>
+    </div>
+  </section>
+</template>
+
+<style scoped>
+/* Copie locale : `.section` appartenait à la page, pas au CSS global. */
+.section {
+  /* Même bloc que dans `AdminSwarmTable.vue`, `SupersedeForm.vue` et
+     `FederationSwarmToggle.vue` : quatre copies d'un motif que la page
+     possédait et que `main.css` ne connaît pas. Le rail bleu est la marque de
+     la famille « exploitation » ; il est ajouté aux quatre à l'identique, et
+     l'en-tête de `AdminSwarmTable.vue` porte la mesure. */
+  --section-tone: var(--chart-1);
+  padding: 1rem 1.1rem;
+  border: 1px solid rgb(var(--line-default));
+  border-left: 3px solid rgb(var(--chart-1) / 0.55);
+  border-radius: var(--radius-lg);
+  background: rgb(var(--bg-surface));
+}
+
+.supersede-lede {
+  max-width: 62ch;
+  margin: 0 0 1rem;
+  /* Elle cite un nom de release entre guillemets : 18 px de débordement à
+     375 px sans point de coupe. */
+  overflow-wrap: anywhere;
+  font-size: 0.8125rem;
+  line-height: 1.55;
+  color: rgb(var(--fg-muted));
+}
+/* Sur la ligne « déjà remplacée », la phrase et le bouton se répondent :
+   la marge basse ferait un décalage vertical entre les deux. */
+.supersede-lede--inline {
+  margin: 0;
+}
+
+.supersede-grid {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: flex-end;
+  gap: 0.85rem;
+}
+.supersede-field {
+  display: flex;
+  flex-direction: column;
+  gap: 0.3rem;
+  min-width: 11rem;
+}
+.supersede-field--hash {
+  flex: 1 1 22rem;
+}
+.supersede-field--reason {
+  flex: 1 1 16rem;
+}
+
+.supersede-actions {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 0.6rem;
+  margin-top: 1rem;
+}
+
+@media (max-width: 40rem) {
+  .supersede-field {
+    flex: 1 1 100%;
+    min-width: 0;
+  }
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/SwarmHealth.vue b/apps/web/app/components/torrent/detail/SwarmHealth.vue
new file mode 100644
index 00000000..dee6b259
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/SwarmHealth.vue
@@ -0,0 +1,239 @@
+<script setup lang="ts">
+/**
+ * « Est-ce que ça va descendre ? » — la réponse avant le clic.
+ *
+ * Trois faits, dans l'ordre où on les cherche : l'état de l'essaim en un mot
+ * (sain, fragile, sans source), la dernière annonce reçue, et la tendance sur
+ * sept jours en courbe. Les deux premiers sortent de la charge de la fiche —
+ * `stats` et les pairs anonymisés portent déjà tout ce qu'il faut. La courbe
+ * vient de `torrent_stats_history`, chargée côté client seulement : elle est
+ * décorative au premier écran et ne vaut pas une requête de plus au rendu
+ * serveur.
+ *
+ * Les seuils : cinq sources et plus, l'essaim tient ; de une à quatre, il
+ * dépend de quelques membres ; zéro, il n'y a rien à télécharger. Ce sont des
+ * seuils de lecture, pas des règles du tracker — ils ne déclenchent rien.
+ */
+const props = withDefaults(
+  defineProps<{
+    hash: string;
+    stats?: { seeders: number; leechers: number } | null;
+    /** Les pairs tels que la fiche les reçoit : anonymisés, avec `lastSeen`. */
+    peers?: ReadonlyArray<{ lastSeen?: string | null }> | null;
+  }>(),
+  { stats: null, peers: null },
+);
+
+const { t, locale } = useI18n();
+
+/**
+ * Le tracé de la courbe part quand la carte ENTRE à l'écran, une fois par
+ * chargement : sous le pli, une courbe déjà dessinée n'aurait rien dit à
+ * personne. La classe reste posée ; les animations, elles, passent par
+ * `--motion-scale` et durent zéro sous « réduire les animations ».
+ */
+const root = ref<HTMLElement | null>(null);
+const seen = ref(false);
+onMounted(() => {
+  if (!root.value || typeof IntersectionObserver === 'undefined') { seen.value = true; return; }
+  const io = new IntersectionObserver(([entry]) => {
+    if (entry?.isIntersecting) { seen.value = true; io.disconnect(); }
+  }, { threshold: 0.4 });
+  io.observe(root.value);
+  onBeforeUnmount(() => io.disconnect());
+});
+
+const seeders = computed(() => props.stats?.seeders ?? 0);
+const state = computed<'healthy' | 'fragile' | 'dead'>(() =>
+  seeders.value >= 5 ? 'healthy' : seeders.value >= 1 ? 'fragile' : 'dead',
+);
+
+/** La dernière annonce reçue, tous pairs confondus. */
+const lastAnnounce = computed(() => {
+  let best = 0;
+  for (const p of props.peers ?? []) {
+    const ts = p.lastSeen ? new Date(p.lastSeen).getTime() : NaN;
+    if (Number.isFinite(ts) && ts > best) best = ts;
+  }
+  return best > 0 ? formatAgo(new Date(best).toISOString(), locale.value) : null;
+});
+
+/* ── La tendance ─────────────────────────────────────────────────────────── */
+interface Point { day: string; seeders: number; leechers: number }
+const { data: history } = useFetch<{ days: number; points: Point[] }>(
+  `/api/torrents/${props.hash}/stats-history`,
+  { lazy: true, server: false, default: () => ({ days: 7, points: [] }) },
+);
+
+/**
+ * Les points tracés : l'historique, puis la valeur du MOMENT comme dernier
+ * point. Le jour courant est déjà dans l'historique si le collecteur est passé
+ * aujourd'hui — la valeur vivante le remplace, elle est plus fraîche.
+ */
+const points = computed(() => {
+  const today = new Date().toISOString().slice(0, 10);
+  const hist = (history.value?.points ?? []).filter((p) => p.day !== today);
+  return [...hist.map((p) => p.seeders), seeders.value];
+});
+const hasCurve = computed(() => points.value.length >= 2);
+
+const W = 120, H = 38, PAD = 3;
+const curve = computed(() => {
+  const v = points.value;
+  const n = v.length;
+  if (n < 2) return null;
+  const max = Math.max(1, ...v);
+  const x = (i: number) => PAD + (i * (W - 2 * PAD)) / (n - 1);
+  const y = (val: number) => H - PAD - (val / max) * (H - 2 * PAD - 4);
+  const line = v.map((val, i) => `${i === 0 ? 'M' : 'L'}${x(i).toFixed(1)} ${y(val).toFixed(1)}`).join(' ');
+  const area = `${line} L${x(n - 1).toFixed(1)} ${H - PAD} L${x(0).toFixed(1)} ${H - PAD} Z`;
+  return { line, area, endX: x(n - 1), endY: y(v[n - 1]!) };
+});
+const curveLabel = computed(() =>
+  t('torrents.detail.health.sparkAria', { n: points.value.length, values: points.value.join(', ') }),
+);
+</script>
+
+<template>
+  <div ref="root" class="sh" :class="{ 'sh--seen': seen }" :data-state="state">
+    <div class="sh-text">
+      <p class="sh-state">
+        <span class="sh-pip" aria-hidden="true" />
+        {{ $t(`torrents.detail.health.${state}`) }}
+      </p>
+      <p class="sh-why">
+        <!-- « Aucune source » puis « 0 sources » disait deux fois la même
+             chose. Sous zéro, ce qui informe c'est la dernière annonce — ou
+             qu'il n'y en a jamais eu. -->
+        <template v-if="state === 'dead'">
+          {{ lastAnnounce
+            ? $t('torrents.detail.health.lastAnnounceAlone', { when: lastAnnounce })
+            : $t('torrents.detail.health.nobody') }}
+        </template>
+        <template v-else>
+          {{ $t('torrents.detail.health.sources', { n: seeders.toLocaleString(locale) }, seeders) }}
+          <template v-if="lastAnnounce">
+            <span class="sh-dot" aria-hidden="true">·</span>
+            {{ $t('torrents.detail.health.lastAnnounce', { when: lastAnnounce }) }}
+          </template>
+        </template>
+      </p>
+    </div>
+
+    <!-- La courbe : sept jours de sources, le dernier point est maintenant.
+         Décorative pour l'œil, mais son `aria-label` donne les valeurs. -->
+    <svg
+      v-if="curve"
+      class="sh-spark"
+      :viewBox="`0 0 ${W} ${H}`"
+      role="img"
+      :aria-label="curveLabel"
+    >
+      <line class="sh-spark-base" :x1="PAD" :y1="H - PAD" :x2="W - PAD" :y2="H - PAD" />
+      <path class="sh-spark-area" :d="curve.area" />
+      <!-- `pathLength="1"` : le trait se mesure en unités de lui-même, donc
+           le tracé s'anime en CSS sans jamais mesurer la courbe en JS. -->
+      <path class="sh-spark-line" :d="curve.line" pathLength="1" />
+      <circle class="sh-spark-end" :cx="curve.endX" :cy="curve.endY" r="2.5" />
+    </svg>
+    <p v-else class="sh-soon">{{ $t('torrents.detail.health.historySoon') }}</p>
+  </div>
+</template>
+
+<style scoped>
+.sh {
+  --tone: var(--online);
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 0.25rem 0.75rem;
+  align-items: center;
+}
+.sh[data-state='fragile'] { --tone: var(--warning); }
+.sh[data-state='dead'] { --tone: var(--danger); }
+.sh-text { min-width: 0; }
+.sh-state {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.45rem;
+  margin: 0;
+  font-size: 0.875rem;
+  font-weight: 600;
+  color: rgb(var(--fg-strong));
+}
+/* La couleur double le mot, jamais seule : « fragile » est écrit. */
+.sh-pip {
+  width: 0.6rem;
+  height: 0.6rem;
+  border-radius: 50%;
+  background: rgb(var(--tone));
+  box-shadow: 0 0 0 4px rgb(var(--tone) / 0.18);
+}
+/* Un essaim vivant respire trois fois après l'arrivée, à faible amplitude,
+   puis se fige. Un essaim mort ne bouge pas. */
+.sh:not([data-state='dead']) .sh-pip {
+  animation: sh-breathe calc(1.6s * var(--motion-scale)) ease-in-out 3;
+}
+@keyframes sh-breathe {
+  0%, 100% { box-shadow: 0 0 0 4px rgb(var(--tone) / 0.18); }
+  50% { box-shadow: 0 0 0 9px rgb(var(--tone) / 0.07); }
+}
+/* La courbe se dessine de gauche à droite quand elle entre à l'écran, l'aire
+   suit, le point du présent surgit en dernier. */
+.sh--seen .sh-spark-line {
+  stroke-dasharray: 1;
+  stroke-dashoffset: 1;
+  animation: sh-draw calc(600ms * var(--motion-scale)) var(--ease-emphasis) forwards;
+}
+@keyframes sh-draw {
+  to { stroke-dashoffset: 0; }
+}
+.sh--seen .sh-spark-area {
+  animation: sh-fade calc(300ms * var(--motion-scale)) var(--ease-standard) both;
+  animation-delay: calc(350ms * var(--motion-scale));
+}
+@keyframes sh-fade {
+  from { opacity: 0; }
+}
+.sh--seen .sh-spark-end {
+  transform-box: fill-box;
+  transform-origin: center;
+  animation: sh-pop calc(200ms * var(--motion-scale)) var(--ease-emphasis) both;
+  animation-delay: calc(560ms * var(--motion-scale));
+}
+@keyframes sh-pop {
+  from { opacity: 0; transform: scale(0.4); }
+}
+.sh-why {
+  margin: 0.15rem 0 0;
+  font-size: 0.6875rem;
+  line-height: 1.45;
+  color: rgb(var(--fg-muted));
+  font-variant-numeric: tabular-nums;
+}
+.sh-dot { margin: 0 0.25rem; color: rgb(var(--fg-subtle)); }
+.sh-spark {
+  width: 7.5rem;
+  height: 2.4rem;
+  overflow: visible;
+}
+.sh-spark-base { stroke: rgb(var(--line-default)); stroke-width: 1; }
+.sh-spark-area { fill: rgb(var(--tone) / 0.18); }
+.sh-spark-line { fill: none; stroke: rgb(var(--tone)); stroke-width: 1.5; stroke-linejoin: round; stroke-linecap: round; }
+.sh-spark-end { fill: rgb(var(--tone)); }
+.sh-soon {
+  margin: 0;
+  max-width: 7.5rem;
+  font-size: 0.625rem;
+  line-height: 1.35;
+  text-align: right;
+  color: rgb(var(--fg-subtle));
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .sh:not([data-state='dead']) .sh-pip,
+  .sh--seen .sh-spark-line,
+  .sh--seen .sh-spark-area,
+  .sh--seen .sh-spark-end { animation: none; }
+  .sh--seen .sh-spark-line { stroke-dasharray: none; stroke-dashoffset: 0; }
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/TorrentComments.vue b/apps/web/app/components/torrent/detail/TorrentComments.vue
new file mode 100644
index 00000000..623721b1
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/TorrentComments.vue
@@ -0,0 +1,579 @@
+<script setup lang="ts">
+/**
+ * Les commentaires — une fonctionnalité entière qui existait de bout en bout,
+ * sauf son interface.
+ *
+ * # Ce qui était déjà là
+ *
+ * - Le `GET /api/torrents/:hash` charge `comments` avec leurs auteurs, les plus
+ *   récents d'abord, et le composable les expose.
+ * - Le `POST /api/torrents/:hash/comments` existe, valide `{ content }` à
+ *   5000 caractères par `torrentCommentSchema`, applique la politique d'âge de
+ *   compte de l'uploadeur (`utils/commentPolicy.ts`) et renvoie la ligne créée.
+ * - La notification `comment_on_my_upload` est câblée dans la cloche, les
+ *   réglages, le push web et l'e-mail, et pointe vers `/torrents/{hash}`.
+ *
+ * Et **zéro appelant** du POST dans l'application web. La notification menait
+ * donc à une page qui n'affichait pas le commentaire dont elle prévenait, et le
+ * réglage « restreindre les commentaires » gardait une porte qui n'existait
+ * pas. Il ne manquait que ce fichier.
+ *
+ * # L'ajout optimiste, et pourquoi il ne peut pas doubler
+ *
+ * Le commentaire posté s'affiche avant que la page ne se recharge — sinon la
+ * zone de saisie se vide et rien ne bouge, ce qui se lit comme un échec. Mais
+ * l'appelant rafraîchit ensuite le détail, et la même ligne arriverait par les
+ * props : elle apparaîtrait deux fois.
+ *
+ * D'où le filtre par identifiant. La ligne locale est remplacée par celle du
+ * serveur dès la réponse (donc elle porte le vrai `id`), et elle disparaît
+ * d'elle-même à la seconde où les props la contiennent. Aucun doublon, aucun
+ * clignotement, et pas de fenêtre pendant laquelle le commentaire n'est nulle
+ * part.
+ *
+ * # Le contenu est du texte de membre
+ *
+ * Il passe par `DescriptionRender`, qui détecte le format et assainit via
+ * DOMPurify — le même chemin que la description d'un torrent et que la liste de
+ * commentaires de `/federated/[id]`. Pas de `v-html` roulé à la main ici.
+ */
+import { formatAge, formatDate } from '~/utils/format';
+import type { TorrentComment } from '~/composables/useTorrentDetail';
+
+/** Ce que `torrentCommentSchema` accepte. Le compteur et le serveur disent le même nombre. */
+const MAX_LENGTH = 5000;
+
+const props = withDefaults(
+  defineProps<{
+    /** L'infohash, pour la route de publication. */
+    hash: string;
+    /** La PREMIÈRE page, telle que le composable l'expose : les plus récents d'abord. */
+    comments: TorrentComment[];
+    /** Le fil entier — la fiche n'en embarque qu'une page. */
+    total?: number;
+    /** Pour distinguer l'auteur de la release dans son propre fil. */
+    uploaderId?: string | null;
+    /** Une page sous péage adulte n'affiche ni fil ni zone de saisie. */
+    gated?: boolean;
+  }>(),
+  { uploaderId: null, gated: false, total: 0 },
+);
+
+const emit = defineEmits<{
+  /** Publié. L'appelant rafraîchit le détail — la ligne est déjà à l'écran. */
+  (e: 'posted', comment: TorrentComment): void;
+}>();
+
+const { t } = useI18n();
+const { loggedIn, user } = useUserSession();
+const fid = useFieldIds();
+
+/* ── Le fil ───────────────────────────────────────────────────────────────── */
+
+const posted = ref<TorrentComment[]>([]);
+/* Les pages plus anciennes, demandées à la main. */
+const older = ref<TorrentComment[]>([]);
+const loadingOlder = ref(false);
+const olderError = ref(false);
+
+const rows = computed<TorrentComment[]>(() => {
+  const known = new Set(props.comments.map((c) => c.id));
+  const seen = new Set<string>();
+  return [...posted.value.filter((c) => !known.has(c.id)), ...props.comments, ...older.value].filter((c) => {
+    if (seen.has(c.id)) return false;
+    seen.add(c.id);
+    return true;
+  });
+});
+/* Reste-t-il quelque chose derrière ? Le compte du serveur contre ce qui est à l'écran. */
+const hasOlder = computed(() => props.comments.length + older.value.length < props.total);
+async function loadOlder() {
+  if (loadingOlder.value) return;
+  const last = [...props.comments, ...older.value].at(-1);
+  if (!last) return;
+  loadingOlder.value = true;
+  olderError.value = false;
+  try {
+    const res = await $fetch<{ items: TorrentComment[]; more: boolean }>(`/api/torrents/${props.hash}/comments`, {
+      // La date ET l'identifiant : deux commentaires peuvent partager la seconde.
+      query: { before: last.createdAt, beforeId: last.id },
+    });
+    older.value = [...older.value, ...res.items];
+  } catch {
+    olderError.value = true;
+  } finally {
+    loadingOlder.value = false;
+  }
+}
+// Changer de release remet le fil à zéro : les pages chargées appartenaient à l'autre.
+watch(
+  () => props.hash,
+  () => {
+    older.value = [];
+    posted.value = [];
+    olderError.value = false;
+  },
+);
+
+/** L'initiale de l'avatar. Un compte effacé n'a plus de nom : la puce reste. */
+function initial(c: TorrentComment): string {
+  return (c.author?.username ?? '?').trim().charAt(0).toUpperCase() || '?';
+}
+
+function isUploader(c: TorrentComment): boolean {
+  return !!props.uploaderId && c.author?.id === props.uploaderId;
+}
+
+/* ── La saisie ────────────────────────────────────────────────────────────── */
+
+const draft = ref('');
+const sending = ref(false);
+const errorMessage = ref('');
+
+const remaining = computed(() => MAX_LENGTH - draft.value.length);
+const tooLong = computed(() => remaining.value < 0);
+const canSend = computed(
+  () => !sending.value && draft.value.trim().length > 0 && !tooLong.value,
+);
+
+async function send() {
+  if (!canSend.value) return;
+  const content = draft.value.trim();
+
+  // La ligne locale, posée AVANT la requête. Son identifiant est temporaire et
+  // ne peut pas collider avec un UUID du serveur.
+  const tempId = `pending-${Date.now()}`;
+  const optimistic: TorrentComment = {
+    id: tempId,
+    content,
+    createdAt: new Date().toISOString(),
+    // L'auteur, c'est le membre : sans lui la ligne disait « compte supprimé » le temps de l'envoi.
+    author: user.value ? ({ id: user.value.id, username: user.value.username } as TorrentComment['author']) : null,
+  };
+  posted.value = [optimistic, ...posted.value];
+  draft.value = '';
+  errorMessage.value = '';
+  sending.value = true;
+
+  try {
+    const created = await $fetch<TorrentComment>(
+      `/api/torrents/${props.hash}/comments`,
+      { method: 'POST', body: { content } },
+    );
+    // Remplacée par la ligne du serveur : elle porte le vrai `id`, donc le
+    // filtre de `rows` saura la retirer quand les props l'apporteront.
+    posted.value = posted.value.map((c) => (c.id === tempId ? created : c));
+    /*
+     * Les pages plus anciennes repartent de zéro.
+     *
+     * La première page se décale d'un cran quand un commentaire arrive : le
+     * plus ancien qu'elle portait sort de sa fenêtre, et il n'était dans
+     * aucune des pages déjà chargées — il disparaissait du fil, et le curseur
+     * (pris sur la dernière ligne chargée) ne le ramenait jamais. On les
+     * redemande, le bouton revient de lui-même.
+     */
+    older.value = [];
+    emit('posted', created);
+  } catch (err: unknown) {
+    // Retirée. Un commentaire affiché que le serveur a refusé est un mensonge,
+    // et le texte est rendu à la zone de saisie pour ne pas être perdu.
+    posted.value = posted.value.filter((c) => c.id !== tempId);
+    draft.value = content;
+    errorMessage.value = messageFor(err);
+  } finally {
+    sending.value = false;
+  }
+}
+
+/**
+ * Le refus, dit en français plutôt qu'en code d'erreur.
+ *
+ * La politique d'âge de compte renvoie un 403 avec le nombre de jours restants
+ * dans la charge utile — précisément pour que l'interface puisse dire combien
+ * de temps attendre au lieu d'un « interdit » sec. Personne ne lisait ce champ.
+ */
+function messageFor(err: unknown): string {
+  const e = err as {
+    statusCode?: number;
+    data?: { message?: string; data?: { daysRemaining?: number }; daysRemaining?: number };
+  };
+  const body = e?.data;
+  if (body?.message === 'COMMENTS_RESTRICTED_ACCOUNT_AGE') {
+    const days = body?.data?.daysRemaining ?? body?.daysRemaining ?? 0;
+    return t('torrents.detail.comments.errors.restricted', { n: days });
+  }
+  if (e?.statusCode === 429) return t('torrents.detail.comments.errors.tooFast');
+  if (e?.statusCode === 401) return t('torrents.detail.comments.errors.signIn');
+  return t('torrents.detail.comments.errors.failed');
+}
+</script>
+
+<template>
+  <section v-if="!gated" class="cm">
+    <SectionHead
+      :title="$t('torrents.detail.comments.title')"
+      :count="rows.length"
+      icon="ph:chat-circle-dots-bold"
+    />
+
+    <!-- ── La zone de saisie ────────────────────────────────────────────── -->
+    <form v-if="loggedIn" class="cm-composer" @submit.prevent="send">
+      <!-- Un `<label for>` apparié et VISIBLE. Un `<label>` qui ne désigne
+           rien n'est qu'un paragraphe stylé : le lecteur d'écran annonce
+           « saisie de texte » sans nom, et `formControlNames.test.ts` fait
+           échouer la construction. -->
+      <label class="cm-label" :for="fid('comment')">
+        {{ $t('torrents.detail.comments.composerLabel') }}
+      </label>
+      <textarea
+        :id="fid('comment')"
+        v-model="draft"
+        class="input cm-textarea"
+        rows="3"
+        :maxlength="MAX_LENGTH"
+        :placeholder="$t('torrents.detail.comments.placeholder')"
+        :aria-describedby="fid('comment-counter')"
+        :disabled="sending"
+      />
+      <div class="cm-composer-foot">
+        <!-- Le compteur ne s'affiche qu'à l'approche de la limite : un compteur
+             permanent sur un champ de 5000 caractères ne fait que du bruit. -->
+        <span
+          :id="fid('comment-counter')"
+          class="cm-counter"
+          :class="{ 'cm-counter--over': tooLong }"
+        >
+          <template v-if="remaining <= 500">
+            {{ $t('torrents.detail.comments.remaining', { n: remaining }) }}
+          </template>
+        </span>
+        <button type="submit" class="tool-btn tool-btn--text cm-send" :disabled="!canSend">
+          <Icon :name="sending ? 'ph:circle-notch-bold' : 'ph:paper-plane-tilt-bold'" aria-hidden="true" />
+          {{ sending ? $t('torrents.detail.comments.sending') : $t('torrents.detail.comments.send') }}
+        </button>
+      </div>
+      <p v-if="errorMessage" class="cm-error" role="alert">
+        <Icon name="ph:warning-circle-fill" aria-hidden="true" />
+        {{ errorMessage }}
+      </p>
+    </form>
+    <p v-else class="cm-signin">
+      <Icon name="ph:sign-in-bold" aria-hidden="true" />
+      {{ $t('torrents.detail.comments.signInToComment') }}
+    </p>
+
+    <!-- ── Le fil ───────────────────────────────────────────────────────── -->
+    <ul v-if="rows.length" class="cm-list">
+      <li
+        v-for="c in rows"
+        :key="c.id"
+        class="cm-item"
+        :data-uploader="isUploader(c) ? 'true' : 'false'"
+      >
+        <span class="cm-avatar" aria-hidden="true">{{ initial(c) }}</span>
+        <div class="cm-body">
+          <p class="cm-meta">
+            <NuxtLink v-if="c.author" :to="`/users/${c.author.id}`" class="cm-who">
+              {{ c.author.username }}
+            </NuxtLink>
+            <span v-else class="cm-who cm-who--gone">
+              {{ $t('torrents.detail.comments.authorGone') }}
+            </span>
+            <span v-if="isUploader(c)" class="cm-badge">
+              {{ $t('torrents.detail.comments.uploaderBadge') }}
+            </span>
+            <time :datetime="c.createdAt" :title="formatDate(c.createdAt)">
+              {{ formatAge(c.createdAt) }}
+            </time>
+          </p>
+          <!-- Assaini par le même chemin que partout ailleurs, et rendu au
+               serveur : `isomorphic-dompurify` fonctionne sous Node.
+
+               C'était un `<ClientOnly>` avec le contenu BRUT en repli. Le
+               repli EST ce que le serveur rend — donc un commentaire écrit en
+               BBCode partait sur le fil avec ses crochets visibles,
+               `[quote=…]` compris, jusqu'à l'hydratation ; et le `<p>` du
+               repli remplacé par le `<div>` du rendu réel comptait comme une
+               non-concordance d'hydratation. -->
+          <div class="cm-text">
+            <DescriptionRender :source="c.content" />
+          </div>
+        </div>
+      </li>
+    </ul>
+    <div v-if="hasOlder" class="cm-more">
+      <button type="button" class="tool-btn tool-btn--text" :disabled="loadingOlder" @click="loadOlder">
+        <Icon :name="loadingOlder ? 'ph:circle-notch-bold' : 'ph:clock-counter-clockwise-bold'" :class="{ 'animate-spin': loadingOlder }" aria-hidden="true" />
+        {{ $t('torrents.detail.comments.loadOlder') }}
+      </button>
+      <p v-if="olderError" class="cm-error" role="alert">{{ $t('torrents.detail.comments.loadOlderFailed') }}</p>
+    </div>
+
+    <!-- L'état vide, sur le modèle de `/federated/[id]` : une icône, une
+         phrase, et pas un cadre d'erreur — il n'y a rien d'anormal à un fil
+         vide. -->
+    <div v-else class="cm-empty">
+      <span class="cm-empty-plate" aria-hidden="true">
+        <Icon name="ph:chat-circle-dots" class="cm-empty-icon" />
+      </span>
+      <p>{{ $t('torrents.detail.comments.empty') }}</p>
+    </div>
+  </section>
+</template>
+
+<style scoped>
+.cm {
+  /* La famille « communauté » : ce que les MEMBRES ont produit — les
+     commentaires, les autres versions. Une des quatre teintes de la page (or =
+     la release, cyan = le contenu du fichier, violet = les membres, bleu =
+     l'équipe), et la seule prise dans l'échelle catégorielle `--chart-*`, qui
+     était entièrement inutilisée. Voir l'en-tête de `NfoPanel.vue`.
+     `--chart-4` tient 3,71:1 en sombre et 3,82:1 en clair sur les surfaces de
+     la fiche : au-dessus des 3:1 d'un élément non textuel, sous les 4,5:1 d'un
+     texte — elle n'en peint donc aucun. */
+  --section-tone: var(--chart-4);
+  display: block;
+}
+
+/* ── Saisie ───────────────────────────────────────────────────────────────── */
+
+.cm-composer {
+  display: flex;
+  flex-direction: column;
+  gap: 0.35rem;
+  margin-bottom: 1rem;
+}
+.cm-label {
+  font-family: var(--font-mono);
+  font-size: var(--label-md, 0.625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+}
+.cm-textarea {
+  min-height: 4.5rem;
+  resize: vertical;
+  font-size: 0.8125rem;
+  line-height: 1.55;
+}
+.cm-composer-foot {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.75rem;
+}
+.cm-counter {
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  color: rgb(var(--fg-muted));
+  font-variant-numeric: tabular-nums;
+}
+.cm-counter--over { color: rgb(var(--danger)); font-weight: 700; }
+.cm-send { flex: none; }
+
+.cm-error {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.35rem;
+  margin: 0;
+  padding: 0.45rem 0.6rem;
+  border: 1px solid rgb(var(--danger) / 0.4);
+  border-radius: var(--radius-sm);
+  background: rgb(var(--danger) / 0.08);
+  font-size: 0.78125rem;
+  line-height: 1.5;
+  color: rgb(var(--fg-default));
+}
+
+.cm-signin {
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+  margin: 0 0 1rem;
+  padding: 0.6rem 0.75rem;
+  border: 1px solid rgb(var(--line-default));
+  border-radius: var(--radius-md);
+  background: rgb(var(--bg-inset));
+  font-size: 0.78125rem;
+  color: rgb(var(--fg-muted));
+}
+
+/* ── Fil ──────────────────────────────────────────────────────────────────── */
+
+.cm-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0.45rem;
+}
+/* Une carte de commentaire : voile de la teinte de famille à 6 %, filet à
+   gauche, encre NEUTRE. Mesuré — `--fg-default` sur un voile de `--chart-4` à
+   6 % donne 15,72:1 en sombre et 16,96:1 en clair, `--fg-muted` 6,35:1 et
+   6,39:1. Le fil se lit donc comme une conversation et non comme une liste de
+   lignes de journal, sans qu'une seule paire descende. */
+.cm-item {
+  display: grid;
+  grid-template-columns: 1.75rem minmax(0, 1fr);
+  gap: 0.6rem;
+  padding: 0.6rem 0.8rem;
+  background:
+    linear-gradient(rgb(var(--chart-4) / 0.06), rgb(var(--chart-4) / 0.06)),
+    rgb(var(--bg-elevated));
+  border: 1px solid rgb(var(--line-default));
+  border-left: 2px solid rgb(var(--chart-4) / 0.45);
+  border-radius: var(--radius-md);
+  transition: border-color var(--dur-3) var(--ease-standard);
+}
+/* Le commentaire de l'uploadeur prend l'or : c'est la voix de la release, pas
+   une voix de la communauté. La carte le dit avant l'avatar. */
+.cm-item[data-uploader='true'] {
+  background:
+    linear-gradient(rgb(var(--accent-warm) / 0.07), rgb(var(--accent-warm) / 0.07)),
+    rgb(var(--bg-elevated));
+  border-left-color: rgb(var(--accent-warm));
+}
+
+/* Une entrée en escalier de 40 ms par carte, plafonnée à six : un fil qui
+   apparaît d'un bloc ne dit pas qu'il est ordonné, et au-delà de six
+   l'attente devient perceptible. `--motion-scale: 0` la supprime par le
+   `calc()`, comme toutes les autres. */
+.cm-item {
+  animation: cm-in calc(220ms * var(--motion-scale)) var(--ease-emphasis) both;
+}
+.cm-item:nth-child(1) { animation-delay: calc(0ms * var(--motion-scale)); }
+.cm-item:nth-child(2) { animation-delay: calc(40ms * var(--motion-scale)); }
+.cm-item:nth-child(3) { animation-delay: calc(80ms * var(--motion-scale)); }
+.cm-item:nth-child(4) { animation-delay: calc(120ms * var(--motion-scale)); }
+.cm-item:nth-child(5) { animation-delay: calc(160ms * var(--motion-scale)); }
+.cm-item:nth-child(n + 6) { animation-delay: calc(200ms * var(--motion-scale)); }
+@keyframes cm-in {
+  from { opacity: 0; transform: translateY(4px); }
+  to { opacity: 1; transform: none; }
+}
+@media (prefers-reduced-motion: reduce) {
+  .cm-item {
+    animation: none;
+  }
+}
+
+.cm-avatar {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 1.75rem;
+  height: 1.75rem;
+  font-size: 0.6875rem;
+  font-weight: 800;
+  background: rgb(var(--bg-inset));
+  border: 1px solid rgb(var(--line-strong));
+  border-radius: var(--radius-sm);
+  color: rgb(var(--fg-muted));
+}
+/* La paire pleine `--accent-warm` / `--accent-warm-fg`, jamais
+   `--accent-warm-text` sur un voile de `--accent-warm` : cette dernière est
+   mesurée sous 4,5:1 en thème clair. */
+.cm-item[data-uploader='true'] .cm-avatar {
+  background: rgb(var(--accent-warm));
+  border-color: rgb(var(--accent-warm));
+  color: rgb(var(--accent-warm-fg));
+}
+
+.cm-body { min-width: 0; }
+
+.cm-meta {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 0.3rem 0.5rem;
+  margin: 0;
+  font-size: 0.6875rem;
+  color: rgb(var(--fg-muted));
+  font-variant-numeric: tabular-nums;
+}
+.cm-who {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 19 px avant, à TOUTES
+     les largeurs — ce n'est pas un défaut de mise en page, c'est un oubli. */
+  display: inline-flex;
+  align-items: center;
+  min-height: 1.5rem;
+  font-family: var(--font-sans);
+  font-size: 0.78125rem;
+  font-weight: 700;
+  color: rgb(var(--fg-strong));
+  text-decoration: none;
+}
+.cm-who:hover { color: rgb(var(--accent)); }
+.cm-who--gone { font-weight: 600; color: rgb(var(--fg-muted)); font-style: italic; }
+
+.cm-badge {
+  padding: 0.02rem 0.35rem;
+  border-radius: var(--radius-sm);
+  background: rgb(var(--accent-warm));
+  border: 1px solid rgb(var(--accent-warm));
+  color: rgb(var(--accent-warm-fg));
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: 800;
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+}
+
+.cm-text { margin-top: 0.2rem; }
+/* `.cm-text-plain` est partie avec le repli `<ClientOnly>` qui l'utilisait :
+   plus aucun gabarit ne pose cette classe. La typographie du corps vient de
+   `DescriptionRender`, qui la porte pour toutes ses surfaces. */
+
+/* L'état vide. Il était un cadre pointillé gris avec un glyphe gris dedans :
+   correct, et parfaitement morne. Il porte maintenant la trame de fond du site
+   — `--bg-pattern-image` existait et n'était utilisée qu'à un seul endroit de
+   la page — plus un voile de la teinte de famille. Un vide texturé se lit
+   comme « pas encore », un vide plat comme « cassé ». */
+.cm-empty {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 0.6rem;
+  padding: 2rem 1rem;
+  background:
+    var(--bg-pattern-image),
+    linear-gradient(rgb(var(--chart-4) / 0.05), rgb(var(--chart-4) / 0.05)),
+    rgb(var(--bg-inset));
+  background-size: var(--bg-pattern-step) var(--bg-pattern-step), auto, auto;
+  border: 1px dashed rgb(var(--chart-4) / 0.35);
+  border-radius: var(--radius-lg);
+  color: rgb(var(--fg-muted));
+  text-align: center;
+}
+/* La plaque reste NEUTRE sous un glyphe teinté : une teinte sur un voile
+   d'elle-même tombe à 3,32:1 en clair pour `--chart-4`, sous les 3:1 dès
+   qu'on monte l'alpha. Fond neutre, glyphe teinté, la paire tient. */
+.cm-empty-plate {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 2.5rem;
+  height: 2.5rem;
+  background: rgb(var(--bg-elevated));
+  border: 1px solid rgb(var(--chart-4) / 0.4);
+  border-radius: var(--radius-pill);
+}
+.cm-empty-icon {
+  font-size: 1.25rem;
+  color: rgb(var(--chart-4));
+}
+.cm-empty p {
+  margin: 0;
+  max-width: 34ch;
+  font-size: 0.8125rem;
+  line-height: 1.55;
+}
+.cm-more {
+  display: grid;
+  justify-items: center;
+  gap: 0.35rem;
+  margin-top: 0.75rem;
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/TrackTables.vue b/apps/web/app/components/torrent/detail/TrackTables.vue
new file mode 100644
index 00000000..5099e4be
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/TrackTables.vue
@@ -0,0 +1,637 @@
+<script setup lang="ts">
+/**
+ * Les pistes audio et de sous-titres, modélisées.
+ *
+ * # Le correctif structurel de la page
+ *
+ * V3X consacre 71 % de sa fiche à la description de l'uploadeur, C411 58 % — et
+ * dans les deux cas ce texte REDIT ce que le site sait déjà : résolution,
+ * codec, taille, tout est déjà en base et déjà affiché. La seule information
+ * réellement neuve qu'il porte, c'est la liste des pistes : quelles langues,
+ * quels sous-titres, forcés ou non, malentendants ou non. C'est aussi la seule
+ * qui décide un téléchargement pour qui ne regarde pas en VO.
+ *
+ * Modélisée ici, elle sort du pavé de BBCode — et la description redevient ce
+ * qu'elle devrait être : une légende.
+ *
+ * # D'où viennent les données, et pourquoi ce n'est pas idéal
+ *
+ * **Le schéma n'a aucune colonne par piste.** `torrents` porte `nfo` (texte),
+ * `description` (texte), et la qualité vit dans les TAGS (`resolution`,
+ * `codec`, `source`) — rien de structuré sur l'audio ni les sous-titres, et
+ * aucune colonne `media_info`. Les pistes sont donc ANALYSÉES depuis le texte
+ * MediaInfo trouvé dans le NFO ou dans la description.
+ *
+ * L'analyseur n'est pas écrit ici : `parseMediaInfoText()` existe déjà dans
+ * `app/utils/mediainfo.ts`, il sert au formulaire d'upload (le membre y colle
+ * sa sortie MediaInfo), il est testé, et il tolère les libellés français comme
+ * anglais. Une deuxième grammaire aurait dérivé de la première.
+ *
+ * Ce que ça implique, et qui doit être dit : un uploadeur qui n'a collé aucun
+ * bloc MediaInfo n'aura pas de pistes, et la section ne se rendra pas. Le
+ * correctif propre serait des colonnes par piste alimentées à l'upload — le
+ * formulaire construit DÉJÀ un `TechnicalSheet` complet et le jette dans du
+ * BBCode. La légende de la section dit d'où vient ce qu'elle montre.
+ */
+import {
+  formatBitRate,
+  parseMediaInfoText,
+  prettyAudioFormat,
+  type MediaTrack,
+} from '~/utils/mediainfo';
+
+const props = withDefaults(
+  defineProps<{
+    /** Le NFO. Première source essayée : c'est là que MediaInfo est collé. */
+    nfo?: string | null;
+    /** La description. Repli — beaucoup d'uploadeurs y collent le bloc. */
+    description?: string | null;
+  }>(),
+  { nfo: null, description: null },
+);
+
+const { t, locale } = useI18n();
+const {
+  open: audioOpen,
+  toggle: toggleAudio,
+  forced: audioForced,
+} = useDetailDisclosure();
+const { open: subsOpen, toggle: toggleSubs, forced: subsForced } = useDetailDisclosure();
+const fid = useFieldIds();
+/* Le bloc qui remplace l'autre entre en 200 ms — mais seulement après un
+   geste : au chargement, un résumé qui se fond serait du mouvement pour rien. */
+const interacted = ref(false);
+
+/**
+ * La première source qui donne des pistes gagne.
+ *
+ * Dans cet ordre parce que le NFO est le champ prévu pour ça, et parce qu'une
+ * description peut contenir un bloc MediaInfo tronqué (un `[spoiler]` fermé
+ * trop tôt) là où le NFO est copié tel quel.
+ */
+const parsed = computed(() => {
+  for (const [source, raw] of [
+    ['nfo', props.nfo],
+    ['description', props.description],
+  ] as const) {
+    if (!raw) continue;
+    const sheet = parseMediaInfoText(raw);
+    if (sheet.audio.length || sheet.text.length) return { sheet, source };
+  }
+  return null;
+});
+
+const video = computed(() => parsed.value?.sheet.video ?? []);
+const audio = computed(() => parsed.value?.sheet.audio ?? []);
+const subs = computed(() => parsed.value?.sheet.text ?? []);
+const total = computed(() => video.value.length + audio.value.length + subs.value.length);
+
+/**
+ * Le résumé n'énumère pas au-delà de quatre pistes par nature : une fiche de
+ * vingt pistes audio (les remux multilingues en ont) redeviendrait un mur.
+ *
+ * Au-delà, « +16 autres » est un BOUTON, et le tableau complet prend la place
+ * des quatre lignes — jamais les deux à la fois. La version précédente rendait
+ * le résumé PUIS un tableau replié dessous : ouvert, les quatre premières
+ * pistes se lisaient deux fois ; fermé, deux commandes (« +16 autres » inerte
+ * et un chevron) désignaient la même chose. Mesuré sur Re:ZERO, 20 pistes
+ * audio et 18 de sous-titres.
+ */
+const SUMMARY_MAX = 4;
+const audioShown = computed(() => audio.value.slice(0, SUMMARY_MAX));
+const subsShown = computed(() => subs.value.slice(0, SUMMARY_MAX));
+const audioMore = computed(() => Math.max(0, audio.value.length - SUMMARY_MAX));
+const subsMore = computed(() => Math.max(0, subs.value.length - SUMMARY_MAX));
+/* Le tableau ne remplace le résumé que s'il a quelque chose de plus à dire :
+   à quatre pistes ou moins, « tout afficher » n'a rien à déplier ici. */
+const audioDetail = computed(() => audioMore.value > 0 && audioOpen.value);
+const subsDetail = computed(() => subsMore.value > 0 && subsOpen.value);
+
+/** Les faits d'une piste vidéo, dans l'ordre où on les cherche. */
+function videoFacts(tr: MediaTrack): string[] {
+  const out: string[] = [];
+  if (tr.format) out.push(tr.profile ? `${tr.format} ${tr.profile}` : tr.format);
+  if (tr.width && tr.height) out.push(`${tr.width} × ${tr.height}`);
+  if (tr.frameRate) out.push(`${tr.frameRate} ${t('torrents.detail.tracks.fps')}`);
+  // L'analyseur garde le nombre nu (« 8 ») ; seul, il ne dit rien.
+  if (tr.bitDepth) out.push(/^\d+$/.test(tr.bitDepth) ? `${tr.bitDepth} bits` : tr.bitDepth);
+  const br = formatBitRate(tr.bitRate, tr.bitRateUnit);
+  if (br) out.push(br);
+  return out;
+}
+const source = computed(() => parsed.value?.source ?? null);
+
+/**
+ * `fr` → « français ». MediaInfo écrit tantôt le code, tantôt le nom anglais ;
+ * un code affiché brut n'aide personne, et `Intl` connaît les deux formes.
+ * Toute valeur qu'il refuse ressort inchangée plutôt que vide.
+ */
+const languageName = computed(() => {
+  let dn: Intl.DisplayNames | null = null;
+  try {
+    dn = new Intl.DisplayNames([locale.value], { type: 'language', fallback: 'none' });
+  } catch {
+    dn = null;
+  }
+  return (raw?: string): string => {
+    const v = (raw ?? '').trim();
+    if (!v) return '—';
+    if (!dn || v.length > 3) return v;
+    try {
+      return dn.of(v.toLowerCase()) ?? v;
+    } catch {
+      return v;
+    }
+  };
+});
+
+/** Ce qu'un sous-titre EST, en termes de tracker : intégral, forcé, ou SDH. */
+function subtitleKind(t: MediaTrack): 'sdh' | 'forced' | 'full' {
+  if (t.isSdh) return 'sdh';
+  if (t.isForced) return 'forced';
+  return 'full';
+}
+
+function audioFormat(t: MediaTrack): string {
+  return prettyAudioFormat(t.format, t.profile);
+}
+</script>
+
+<template>
+  <div v-if="total" class="tracks">
+    <!-- ── Le résumé : une ligne par piste, les faits qu'on cherche ────────
+         « Y a-t-il des sous-titres français ? » se lisait dans trente lignes
+         de MediaInfo ou dans deux tableaux repliés. Ici : la vidéo, chaque
+         piste audio, chaque piste de sous-titres, avec la langue, le format et
+         la piste par défaut. Au-delà de quatre, « +N autres » ouvre le tableau
+         complet À LA PLACE des lignes — les colonnes (débit, titre) pour qui
+         veut le détail, sans rien relire. ──────────────────────────────────── -->
+    <section class="tracks-block">
+      <SectionHead
+        :title="$t('torrents.detail.tracks.title')"
+        :count="total"
+        icon="ph:waveform-bold"
+      />
+      <dl class="tsum" :class="{ 'tsum--live': interacted }">
+        <div v-if="video.length" class="tsum-row">
+          <dt class="tsum-k">{{ $t('torrents.detail.tracks.videoTitle') }}</dt>
+          <dd class="tsum-v">
+            <template v-for="(f, i) in videoFacts(video[0]!)" :key="i">
+              <span v-if="i > 0" class="tsum-sep" aria-hidden="true">·</span>
+              <span :class="{ 'tsum-strong': i === 0 || i === 1 }">{{ f }}</span>
+            </template>
+          </dd>
+        </div>
+
+        <!-- ── Audio ── -->
+        <div v-if="audioDetail" class="tsum-row tsum-row--open">
+          <dt class="tsum-k">{{ $t('torrents.detail.tracks.audioTitle') }}</dt>
+          <dd class="tsum-v tsum-v--open">
+            <span>{{ $t('torrents.detail.tracks.count', { n: audio.length }, audio.length) }}</span>
+            <!-- Sous « tout afficher », la case globale commande : pas de
+                 bouton qui ne ferait rien. -->
+            <button
+              v-if="!audioForced"
+              type="button"
+              class="tsum-btn"
+              aria-expanded="true"
+              :aria-controls="fid('audio')"
+              :title="$t('torrents.detail.tracks.collapseAudio')"
+              @click="(interacted = true), toggleAudio()"
+            >
+              {{ $t('torrents.detail.tracks.less') }}
+              <Icon name="ph:caret-down-bold" class="tsum-caret tsum-caret--open" aria-hidden="true" />
+            </button>
+          </dd>
+          <dd :id="fid('audio')" class="tsum-table">
+            <table class="tracks-table">
+              <caption class="sr-only">{{ $t('torrents.detail.tracks.audioTitle') }}</caption>
+              <thead>
+                <tr>
+                  <th scope="col" class="tracks-num">#</th>
+                  <th scope="col">{{ $t('torrents.detail.tracks.col.language') }}</th>
+                  <th scope="col">{{ $t('torrents.detail.tracks.col.format') }}</th>
+                  <th scope="col">{{ $t('torrents.detail.tracks.col.channels') }}</th>
+                  <th scope="col" class="tracks-num">{{ $t('torrents.detail.tracks.col.bitrate') }}</th>
+                  <th scope="col">{{ $t('torrents.detail.tracks.col.title') }}</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr v-for="(t, i) in audio" :key="`a${i}`">
+                  <td class="tracks-num">{{ i + 1 }}</td>
+                  <td class="tracks-strong">
+                    {{ languageName(t.language) }}
+                    <!-- Conteneur neutre plus un point : un fond teinté par la
+                         couleur de son texte perd le contraste en thème clair. -->
+                    <span v-if="t.isDefault" class="tracks-flag">
+                      <span class="tracks-flag-dot tracks-flag-dot--default" aria-hidden="true" />
+                      {{ $t('torrents.detail.tracks.flag.default') }}
+                    </span>
+                  </td>
+                  <td class="tracks-strong">{{ audioFormat(t) }}</td>
+                  <td>{{ t.channels ?? '—' }}</td>
+                  <td class="tracks-num">{{ formatBitRate(t.bitRate) ?? '—' }}</td>
+                  <td class="tracks-title">{{ t.title ?? '—' }}</td>
+                </tr>
+              </tbody>
+            </table>
+          </dd>
+        </div>
+        <template v-else>
+          <div v-for="(t, i) in audioShown" :key="`sa${i}`" class="tsum-row tsum-row--sum">
+            <dt class="tsum-k">{{ i === 0 ? $t('torrents.detail.tracks.audioTitle') : '' }}</dt>
+            <dd class="tsum-v">
+              <span class="tsum-strong">{{ languageName(t.language) }}</span>
+              <span class="tsum-sep" aria-hidden="true">·</span>
+              <span class="tsum-strong">{{ t.channels ? `${audioFormat(t)} ${t.channels}` : audioFormat(t) }}</span>
+              <template v-if="formatBitRate(t.bitRate, t.bitRateUnit)">
+                <span class="tsum-sep" aria-hidden="true">·</span>
+                <span>{{ formatBitRate(t.bitRate, t.bitRateUnit) }}</span>
+              </template>
+              <span v-if="t.isDefault" class="tsum-flag">{{ $t('torrents.detail.tracks.flag.default') }}</span>
+            </dd>
+          </div>
+          <div v-if="audioMore" class="tsum-row tsum-row--more">
+            <dt class="tsum-k"></dt>
+            <dd class="tsum-v">
+              <button
+                type="button"
+                class="tsum-btn"
+                aria-expanded="false"
+                :title="$t('torrents.detail.tracks.expandAudio')"
+                @click="(interacted = true), toggleAudio()"
+              >
+                {{ $t('torrents.detail.tracks.more', { n: audioMore }, audioMore) }}
+                <Icon name="ph:caret-down-bold" class="tsum-caret" aria-hidden="true" />
+              </button>
+            </dd>
+          </div>
+        </template>
+
+        <!-- ── Sous-titres ── -->
+        <div v-if="subsDetail" class="tsum-row tsum-row--open">
+          <dt class="tsum-k">{{ $t('torrents.detail.tracks.subsTitle') }}</dt>
+          <dd class="tsum-v tsum-v--open">
+            <span>{{ $t('torrents.detail.tracks.count', { n: subs.length }, subs.length) }}</span>
+            <button
+              v-if="!subsForced"
+              type="button"
+              class="tsum-btn"
+              aria-expanded="true"
+              :aria-controls="fid('subs')"
+              :title="$t('torrents.detail.tracks.collapseSubs')"
+              @click="(interacted = true), toggleSubs()"
+            >
+              {{ $t('torrents.detail.tracks.less') }}
+              <Icon name="ph:caret-down-bold" class="tsum-caret tsum-caret--open" aria-hidden="true" />
+            </button>
+          </dd>
+          <dd :id="fid('subs')" class="tsum-table">
+            <table class="tracks-table">
+              <caption class="sr-only">{{ $t('torrents.detail.tracks.subsTitle') }}</caption>
+              <thead>
+                <tr>
+                  <th scope="col" class="tracks-num">#</th>
+                  <th scope="col">{{ $t('torrents.detail.tracks.col.language') }}</th>
+                  <th scope="col">{{ $t('torrents.detail.tracks.col.format') }}</th>
+                  <th scope="col">{{ $t('torrents.detail.tracks.col.kind') }}</th>
+                  <th scope="col">{{ $t('torrents.detail.tracks.col.title') }}</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr v-for="(t, i) in subs" :key="`s${i}`">
+                  <td class="tracks-num">{{ i + 1 }}</td>
+                  <td class="tracks-strong">
+                    {{ languageName(t.language) }}
+                    <span v-if="t.isDefault" class="tracks-flag">
+                      <span class="tracks-flag-dot tracks-flag-dot--default" aria-hidden="true" />
+                      {{ $t('torrents.detail.tracks.flag.default') }}
+                    </span>
+                  </td>
+                  <td>{{ t.format ?? '—' }}</td>
+                  <td>
+                    <span class="tracks-kind">
+                      <span
+                        class="tracks-flag-dot"
+                        :class="`tracks-flag-dot--${subtitleKind(t)}`"
+                        aria-hidden="true"
+                      />
+                      {{ $t(`torrents.detail.tracks.kind.${subtitleKind(t)}`) }}
+                    </span>
+                  </td>
+                  <td class="tracks-title">{{ t.title ?? '—' }}</td>
+                </tr>
+              </tbody>
+            </table>
+          </dd>
+        </div>
+        <template v-else>
+          <div v-for="(t, i) in subsShown" :key="`ss${i}`" class="tsum-row tsum-row--sum">
+            <dt class="tsum-k">{{ i === 0 ? $t('torrents.detail.tracks.subsTitle') : '' }}</dt>
+            <dd class="tsum-v">
+              <span class="tsum-strong">{{ languageName(t.language) }}</span>
+              <template v-if="t.format">
+                <span class="tsum-sep" aria-hidden="true">·</span>
+                <span class="tsum-strong">{{ t.format }}</span>
+              </template>
+              <template v-if="subtitleKind(t) !== 'full'">
+                <span class="tsum-sep" aria-hidden="true">·</span>
+                <span>{{ $t(`torrents.detail.tracks.kind.${subtitleKind(t)}`) }}</span>
+              </template>
+              <template v-if="t.title">
+                <span class="tsum-sep" aria-hidden="true">·</span>
+                <span class="tsum-title">{{ t.title }}</span>
+              </template>
+              <span v-if="t.isDefault" class="tsum-flag">{{ $t('torrents.detail.tracks.flag.default') }}</span>
+            </dd>
+          </div>
+          <div v-if="subsMore" class="tsum-row tsum-row--more">
+            <dt class="tsum-k"></dt>
+            <dd class="tsum-v">
+              <button
+                type="button"
+                class="tsum-btn"
+                aria-expanded="false"
+                :title="$t('torrents.detail.tracks.expandSubs')"
+                @click="(interacted = true), toggleSubs()"
+              >
+                {{ $t('torrents.detail.tracks.more', { n: subsMore }, subsMore) }}
+                <Icon name="ph:caret-down-bold" class="tsum-caret" aria-hidden="true" />
+              </button>
+            </dd>
+          </div>
+        </template>
+      </dl>
+    </section>
+
+    <!-- D'où vient ce tableau. Une donnée analysée depuis un texte libre n'a
+         pas la même autorité qu'une colonne, et le lecteur a le droit de le
+         savoir. -->
+    <p class="tracks-source">
+      <Icon name="ph:info-bold" class="tracks-source-icon" aria-hidden="true" />
+      {{ source === 'nfo'
+        ? $t('torrents.detail.tracks.sourceNfo')
+        : $t('torrents.detail.tracks.sourceDescription') }}
+    </p>
+  </div>
+</template>
+
+<style scoped>
+.tracks {
+  /* La même famille que le NFO — ce que le fichier contient. Voir l'en-tête de
+     `NfoPanel.vue` pour la clé complète des quatre familles. */
+  --section-tone: var(--accent-cool);
+  display: flex;
+  flex-direction: column;
+  gap: 1.15rem;
+}
+.tracks-block { display: block; }
+
+
+.tracks-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 0.75rem;
+}
+.tracks-table th,
+.tracks-table td {
+  padding: 0.35rem 0.6rem;
+  text-align: left;
+  white-space: nowrap;
+  border-bottom: 1px solid rgb(var(--line-default));
+}
+.tracks-table tbody tr:last-child td { border-bottom: 0; }
+/* L'en-tête de colonne : voile de la teinte de famille à 16 %, encre NEUTRE.
+   `--fg-muted` sur un voile à 16 % de n'importe laquelle des huit teintes, sur
+   les trois fonds de carte et dans les deux thèmes, tient 4,84:1 au pire.
+   C'est le motif qui rend une table colorée sans toucher à une seule paire
+   texte/fond du corps. */
+.tracks-table th {
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+  background:
+    linear-gradient(rgb(var(--accent-cool) / 0.16), rgb(var(--accent-cool) / 0.16)),
+    rgb(var(--bg-inset));
+  border-bottom-color: rgb(var(--accent-cool) / 0.28);
+}
+.tracks-table td {
+  color: rgb(var(--fg-muted));
+  font-variant-numeric: tabular-nums;
+  transition: background-color var(--dur-2) var(--ease-standard);
+}
+/* Vingt pistes audio se lisent en balayant une ligne : le survol la désigne.
+   Voile à 6 % sous encre neutre — `--fg-muted` y tient 6,03:1 en sombre et
+   5,96:1 en clair. */
+.tracks-table tbody tr:hover td {
+  background-color: rgb(var(--accent-cool) / 0.06);
+  color: rgb(var(--fg-default));
+}
+.tracks-strong {
+  color: rgb(var(--fg-default));
+  font-weight: 600;
+}
+/* Les débits s'empilent : alignés à droite en chiffres tabulaires, sinon la
+   comparaison d'une ligne à l'autre demande de lire au lieu de regarder. */
+.tracks-num {
+  text-align: right;
+  font-variant-numeric: tabular-nums;
+}
+.tracks-title {
+  max-width: 18rem;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.tracks-flag,
+.tracks-kind {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.28rem;
+  padding: 0.02rem 0.4rem;
+  border-radius: var(--radius-pill);
+  border: 1px solid rgb(var(--line-default));
+  background: rgb(var(--bg-inset));
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-default));
+  white-space: nowrap;
+}
+.tracks-flag { margin-left: 0.35rem; }
+
+.tracks-flag-dot {
+  flex: none;
+  width: 0.35rem;
+  height: 0.35rem;
+  border-radius: var(--radius-pill);
+  background: rgb(var(--fg-faint));
+}
+.tracks-flag-dot--default { background: rgb(var(--online)); }
+.tracks-flag-dot--full { background: rgb(var(--online)); }
+.tracks-flag-dot--forced { background: rgb(var(--warning)); }
+.tracks-flag-dot--sdh { background: rgb(var(--info)); }
+
+/* La provenance de la table. C'est une note de bas de page, pas un
+   avertissement : un filet de la teinte de famille à gauche, un voile très
+   faible, et l'encre neutre du texte discret. Elle se lit comme une légende. */
+.tracks-source {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.45rem;
+  margin: 0;
+  padding: 0.45rem 0.6rem;
+  background-color: rgb(var(--accent-cool) / 0.06);
+  border-left: 2px solid rgb(var(--accent-cool) / 0.45);
+  border-radius: 0 var(--radius-sm) var(--radius-sm) 0;
+  font-size: 0.71875rem;
+  line-height: 1.5;
+  color: rgb(var(--fg-muted));
+}
+/* Une classe posée sur l'`<Icon>` plutôt qu'un sélecteur d'élément : le
+   composant rend tantôt un `<svg>`, tantôt un `<span>` masqué selon le mode de
+   `@nuxt/icon`, et un sélecteur de balise ne toucherait qu'un des deux. */
+.tracks-source-icon {
+  flex: none;
+  margin-top: 0.15rem;
+  font-size: 0.85rem;
+  color: rgb(var(--accent-cool));
+}
+
+@media (max-width: 720px) {
+  .tracks-table { font-size: 0.71875rem; }
+  .tracks-table th,
+  .tracks-table td { padding: 0.3rem 0.45rem; }
+  .tracks-title { max-width: 9rem; }
+}
+
+/* ── Le résumé des pistes ──────────────────────────────────────────────── */
+.tsum {
+  display: grid;
+  gap: 0.35rem;
+  margin: 0;
+}
+.tsum-row {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  gap: 0.15rem 0.75rem;
+  align-items: baseline;
+  padding: 0.5rem 0.7rem;
+  border: 1px solid rgb(var(--line-default));
+  border-radius: var(--radius-lg);
+  background: rgb(var(--bg-inset));
+}
+@media (min-width: 640px) {
+  .tsum-row { grid-template-columns: 6.5rem minmax(0, 1fr); }
+}
+.tsum-row--more {
+  padding-top: 0.25rem;
+  padding-bottom: 0.25rem;
+  background: transparent;
+  border-color: transparent;
+}
+.tsum-k {
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+  padding-top: 0.15rem;
+}
+.tsum-v {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 0.25rem 0.45rem;
+  margin: 0;
+  font-size: 0.8125rem;
+  color: rgb(var(--fg-muted));
+  font-variant-numeric: tabular-nums;
+}
+.tsum-strong { color: rgb(var(--fg-strong)); font-weight: 600; }
+.tsum-sep { color: rgb(var(--fg-subtle)); }
+.tsum-title { font-style: italic; }
+/* « +16 autres » et « Réduire » : le même texte discret qu'avant, devenu une
+   commande — 24 px de haut pour la cible, un chevron pour le dire. L'anneau de
+   focus est celui de `main.css`. */
+.tsum-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.25rem;
+  min-height: 1.5rem;
+  margin-left: -0.35rem;
+  padding: 0 0.35rem;
+  border: 0;
+  border-radius: var(--radius-sm);
+  background: none;
+  font: inherit;
+  font-size: 0.75rem;
+  font-weight: 600;
+  color: rgb(var(--fg-muted));
+  cursor: pointer;
+  transition:
+    color var(--dur-1) var(--ease-standard),
+    background-color var(--dur-1) var(--ease-standard);
+}
+.tsum-caret { transition: transform var(--dur-2) var(--ease-standard); }
+.tsum-caret--open { transform: rotate(180deg); }
+/* Après un geste, ce qui apparaît descend en place — le tableau à l'ouverture,
+   les quatre lignes au repli. Jamais au premier rendu. */
+.tsum--live .tsum-row--open,
+.tsum--live .tsum-row--sum,
+.tsum--live .tsum-row--more {
+  animation: tsum-in var(--dur-4) var(--ease-emphasis) both;
+}
+@keyframes tsum-in {
+  from { opacity: 0; transform: translateY(-0.25rem); }
+}
+.tsum-btn:hover {
+  color: rgb(var(--fg-strong));
+  background-color: rgb(var(--bg-hover));
+}
+/* La rangée ouverte : le libellé et le compte en haut, le tableau à pleine
+   largeur dessous, collé au bas de la même boîte — un seul objet, pas une
+   carte dans une carte. */
+.tsum-v--open {
+  justify-content: space-between;
+  align-items: center;
+}
+.tsum-v--open .tsum-btn { margin-left: 0; }
+.tsum-table {
+  grid-column: 1 / -1;
+  margin: 0.45rem -0.7rem -0.5rem;
+  overflow-x: auto;
+  border-top: 1px solid rgb(var(--accent-cool) / 0.22);
+  border-radius: 0 0 calc(var(--radius-lg) - 1px) calc(var(--radius-lg) - 1px);
+  background: rgb(var(--bg-elevated));
+}
+/* La piste par défaut : un conteneur neutre et une teinte, jamais un fond de
+   la couleur de son texte — la paire qui tombe sous 4,5:1 en thème clair. */
+.tsum-flag {
+  display: inline-flex;
+  align-items: center;
+  min-height: 1.3rem;
+  padding: 0 0.4rem;
+  border-radius: var(--radius-pill);
+  border: 1px solid rgb(var(--online) / 0.5);
+  color: rgb(var(--online));
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: 700;
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .tsum--live .tsum-row--open,
+  .tsum--live .tsum-row--sum,
+  .tsum--live .tsum-row--more { animation: none; }
+  .tsum-caret { transition: none; }
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/VersionUnitBar.vue b/apps/web/app/components/torrent/detail/VersionUnitBar.vue
new file mode 100644
index 00000000..c69d2720
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/VersionUnitBar.vue
@@ -0,0 +1,531 @@
+<script setup lang="ts">
+/**
+ * L'unité, nommée puis changée.
+ *
+ * # Pourquoi la nommer noir sur blanc
+ *
+ * Le tableau des versions comparait des releases sans jamais dire de QUOI
+ * elles étaient les versions, et le résultat était un mensonge mesuré : la
+ * fiche de `Cats.Eye.S01` étiquetait `Cats.Eye.S02` « Image max » et `S01`
+ * « Léger ». Deux contenus différents présentés comme deux variantes du même.
+ *
+ * Le correctif tient en deux moitiés. `assignVersionMarkers` suppose que la
+ * liste qu'on lui donne EST une unité ; cette barre est l'autre moitié : elle
+ * écrit l'unité en clair — `Épisode  Épisode 09   Saison  Saison 01` — pour
+ * que le lecteur sache sur quoi porte la comparaison AVANT de lire une ligne.
+ * Sans elle, borner l'unité serait devenu invisible, donc indistinguable de
+ * l'ancien comportement.
+ *
+ * Une paire libellé/valeur, pas une phrase : c'est une `<dl>`, ce que c'est
+ * réellement, et un lecteur d'écran l'annonce comme telle.
+ *
+ * # Pourquoi un dépli et non trois listes déroulantes
+ *
+ * Changer d'unité est rare — on arrive sur la fiche de l'épisode qu'on veut.
+ * Trois `<select>` en permanence coûteraient trois contrôles et une hauteur
+ * fixe à chaque visite pour un geste que la plupart ne font jamais. Le dépli
+ * met la navigation à un clic et zéro pixel le reste du temps.
+ *
+ * Une fois ouvert, les trois étages sont ceux de l'API — la portée, les
+ * saisons, les épisodes d'UNE saison — dans cet ordre, parce que c'est
+ * l'ordre dans lequel ils se contraignent : la portée décide s'il y a des
+ * saisons, la saison décide quels épisodes existent.
+ *
+ * # Le vocabulaire est celui de la page de groupe, pas une deuxième copie
+ *
+ * Les libellés de portée passent par `scopeLabelKey` et les clés
+ * `search.group.*` que `/torrents/group/[...key].vue` utilise déjà. Ses
+ * pastilles ne sont PAS extraites ici : elles sont peintes avec un violet
+ * littéral (`rgb(167 139 250 / .18)`), hors jetons de thème. Les extraire
+ * telles quelles importerait la violation dans un fichier neuf, les
+ * normaliser changerait le rendu de la page de groupe — et c'était la
+ * condition. Ce qui est partagé est donc ce qui compte : le type `GroupScope`,
+ * `ScopeSummary` et les traductions.
+ */
+import { scopeLabelKey, type GroupScope, type ScopeSummary } from '~/utils/groupScopes';
+
+/** Un seau de saison, tel que `/api/torrents/group` le renvoie. */
+export interface SeasonBucket {
+  season: number | null;
+  releaseCount: number;
+  episodeCount: number;
+  seeders: number;
+  resolutions: string[];
+}
+
+/**
+ * Un seau d'épisode. Son `season` arrive à `null` et c'est VOULU côté API
+ * (`mixedBuckets`, `by: 'episode'` émet `NULL::smallint AS season`) : la
+ * réponse porte « les épisodes d'UNE saison », et cette saison est ailleurs,
+ * dans `openSeason`. Le champ n'est donc pas lu ici.
+ */
+export interface EpisodeBucket {
+  episode: number | null;
+  releaseCount: number;
+  seeders: number;
+  resolutions: string[];
+}
+
+const props = withDefaults(
+  defineProps<{
+    /** La portée ouverte, telle que la réponse l'a renvoyée. */
+    scope: GroupScope;
+    /** Les découpes que l'œuvre possède réellement. Une seule : pas de choix. */
+    scopes: readonly ScopeSummary[];
+    seasons: readonly SeasonBucket[];
+    openSeason: number | null;
+    episodes: readonly EpisodeBucket[];
+    openEpisode: number | null;
+    /** L'API plafonne à 300 épisodes ; au-delà elle le dit et on le répète. */
+    episodesTruncated?: boolean;
+    /**
+     * L'unité de la release affichée. Le retour arrière : une fois qu'on est
+     * parti voir l'épisode 10, plus rien ne ramène à celui de la page.
+     */
+    homeScope: GroupScope;
+    homeSeason: number | null;
+    homeEpisode: number | null;
+    /**
+     * Une requête est en vol. Les pastilles restent CLIQUABLES : les
+     * désactiver le temps du vol arrache le focus du clavier à celle qu'on
+     * vient d'activer, et un deuxième clic ne coûte qu'une requête de plus —
+     * la clé change, `useFetch` recharge, la dernière réponse gagne.
+     */
+    pending?: boolean;
+  }>(),
+  { episodesTruncated: false, pending: false },
+);
+
+const emit = defineEmits<{
+  /** La portée ET l'unité changent ensemble : une saison n'existe pas partout. */
+  pick: [{ scope: GroupScope; season: number | null; episode: number | null }];
+}>();
+
+const { t } = useI18n();
+
+const open = ref(false);
+
+/** Deux découpes ou plus, ou une autre unité dans celle-ci : il y a un choix. */
+const navigable = computed(
+  () =>
+    props.scopes.length > 1 ||
+    props.seasons.length > 1 ||
+    props.episodes.length > 1,
+);
+
+/** `9` → `09`. Un `E9` au milieu d'une colonne de `E10` casse l'alignement. */
+function pad(n: number): string {
+  return String(n).padStart(2, '0');
+}
+
+function seasonLabel(season: number | null): string {
+  return season === null
+    ? t('search.group.seasonUnknown')
+    : t('search.group.season', { n: pad(season) });
+}
+
+/**
+ * Le nom accessible d'une pastille d'épisode.
+ *
+ * `E09` suivi d'un `4` nu s'annonce « E zéro neuf quatre », ce qui ne dit ni
+ * « épisode » ni « releases ». Les deux clés sont recomposées ici plutôt que
+ * dupliquées en une troisième chaîne à traduire.
+ */
+function episodeAria(e: EpisodeBucket): string | undefined {
+  if (e.episode === null) return undefined;
+  const unit = t('torrents.detail.versions.unit.episodeValue', {
+    n: pad(e.episode),
+  });
+  return `${unit} — ${t('search.group.nReleases', e.releaseCount)}`;
+}
+
+/**
+ * L'unité, en paires. Ce que la barre affiche en permanence.
+ *
+ * L'ordre est celui du tracker de référence — l'épisode d'abord, la saison
+ * ensuite — parce que l'épisode est ce qu'on est venu chercher et la saison
+ * seulement où il se trouve.
+ */
+const pairs = computed<{ key: string; label: string; value: string }[]>(() => {
+  const out: { key: string; label: string; value: string }[] = [];
+  if (props.scope === 'episode') {
+    out.push({
+      key: 'episode',
+      label: t('torrents.detail.versions.unit.episodeLabel'),
+      value:
+        props.openEpisode === null
+          ? '—'
+          : t('torrents.detail.versions.unit.episodeValue', {
+              n: pad(props.openEpisode),
+            }),
+    });
+  }
+  if (props.scope === 'episode' || props.scope === 'season') {
+    out.push({
+      key: 'season',
+      label: t('torrents.detail.versions.unit.seasonLabel'),
+      value: seasonLabel(props.openSeason),
+    });
+  }
+  if (props.scope === 'integral') {
+    out.push({
+      key: 'integral',
+      label: t('torrents.detail.versions.unit.cutLabel'),
+      value: t('torrents.detail.versions.unit.integral'),
+    });
+  }
+  if (props.scope === 'all') {
+    out.push({
+      key: 'all',
+      label: t('torrents.detail.versions.unit.cutLabel'),
+      value: t('torrents.detail.versions.unit.whole'),
+    });
+  }
+  return out;
+});
+
+/** La portée d'une pastille : nouvelle découpe, unité laissée au serveur. */
+function pickScope(scope: GroupScope) {
+  if (scope === props.scope) return;
+  // Revenir sur sa propre découpe, c'est revenir à sa propre unité — sinon le
+  // serveur ouvre le seau le plus récent, qui n'est pas celui de la page.
+  if (scope === props.homeScope) {
+    emit('pick', {
+      scope,
+      season: props.homeSeason,
+      episode: props.homeEpisode,
+    });
+    return;
+  }
+  emit('pick', { scope, season: null, episode: null });
+}
+
+/** Changer de saison remet l'épisode au choix du serveur : le plus récent. */
+function pickSeason(season: number | null) {
+  if (season === props.openSeason) return;
+  emit('pick', { scope: props.scope, season, episode: null });
+}
+
+function pickEpisode(episode: number | null) {
+  if (episode === props.openEpisode) return;
+  emit('pick', { scope: props.scope, season: props.openSeason, episode });
+}
+
+/** Le retour arrière ne s'affiche que quand on en est réellement parti. */
+const away = computed(
+  () =>
+    props.scope !== props.homeScope ||
+    (props.scope !== 'all' &&
+      props.scope !== 'integral' &&
+      props.openSeason !== props.homeSeason) ||
+    (props.scope === 'episode' && props.openEpisode !== props.homeEpisode),
+);
+
+function goHome() {
+  emit('pick', {
+    scope: props.homeScope,
+    season: props.homeSeason,
+    episode: props.homeEpisode,
+  });
+}
+</script>
+
+<template>
+  <div class="unit" :data-pending="pending ? 'true' : 'false'">
+    <div class="unit-bar">
+      <!-- Chaque paire dans sa propre boîte, et pas les `dt`/`dd` en vrac
+           dans le flex : quand la rangée se replie, la coupure tombait ENTRE
+           un intitulé et sa valeur. Mesuré à 390 px — « ÉPISODE  Épisode 09
+           SAISON » sur la première ligne, « Saison 01 » orpheline sur la
+           seconde. Un `<div>` est un enfant valide de `<dl>` et regroupe
+           précisément un terme avec sa définition. -->
+      <dl class="unit-pairs">
+        <div v-for="p in pairs" :key="p.key" class="unit-pair">
+          <dt class="unit-key">{{ p.label }}</dt>
+          <dd class="unit-val">{{ p.value }}</dd>
+        </div>
+      </dl>
+
+      <button
+        v-if="navigable"
+        type="button"
+        class="unit-toggle"
+        :aria-expanded="open"
+        @click="open = !open"
+      >
+        <span>{{ $t('torrents.detail.versions.unit.change') }}</span>
+        <Icon
+          :name="open ? 'ph:caret-up-bold' : 'ph:caret-down-bold'"
+          aria-hidden="true"
+        />
+      </button>
+    </div>
+
+    <div v-if="open && navigable" class="unit-panel">
+      <!-- La portée d'abord : c'est elle qui décide s'il y a des saisons. -->
+      <div v-if="scopes.length > 1" class="unit-row">
+        <span class="unit-row-key">{{ $t('torrents.detail.versions.unit.scopeRow') }}</span>
+        <div class="unit-chips">
+          <button
+            v-for="s in scopes"
+            :key="s.scope"
+            type="button"
+            class="unit-chip"
+            :aria-pressed="s.scope === scope"
+            @click="pickScope(s.scope)"
+          >
+            {{ $t(scopeLabelKey(s.scope), { n: s.units }) }}
+          </button>
+        </div>
+      </div>
+
+      <div v-if="seasons.length > 1" class="unit-row">
+        <span class="unit-row-key">{{ $t('torrents.detail.versions.unit.seasonRow') }}</span>
+        <div class="unit-chips">
+          <button
+            v-for="s in seasons"
+            :key="s.season ?? 'none'"
+            type="button"
+            class="unit-chip"
+            :aria-pressed="s.season === openSeason"
+            @click="pickSeason(s.season)"
+          >
+            {{ seasonLabel(s.season) }}
+            <!-- Ce que le seau contient, pour ne pas avoir à l'ouvrir : des
+                 épisodes quand la découpe en a, des releases sinon. -->
+            <span class="unit-chip-n">{{
+              scope === 'episode'
+                ? $t('search.group.nEpisodes', s.episodeCount)
+                : $t('search.group.nReleases', s.releaseCount)
+            }}</span>
+          </button>
+        </div>
+      </div>
+
+      <div v-if="episodes.length > 1" class="unit-row">
+        <span class="unit-row-key">{{ $t('torrents.detail.versions.unit.episodeRow') }}</span>
+        <div class="unit-chips">
+          <button
+            v-for="e in episodes"
+            :key="e.episode ?? 'none'"
+            type="button"
+            class="unit-chip unit-chip--ep"
+            :aria-pressed="e.episode === openEpisode"
+            :aria-label="episodeAria(e)"
+            @click="pickEpisode(e.episode)"
+          >
+            {{ e.episode === null ? '—' : `E${pad(e.episode)}` }}
+            <span class="unit-chip-n">{{ e.releaseCount }}</span>
+          </button>
+        </div>
+      </div>
+
+      <p v-if="episodesTruncated" class="unit-note">
+        {{ $t('search.group.episodesTruncated') }}
+      </p>
+
+      <p class="unit-note">
+        {{ $t('torrents.detail.versions.unit.hint') }}
+        <button v-if="away" type="button" class="unit-home" @click="goHome">
+          {{ $t('torrents.detail.versions.unit.backHere') }}
+        </button>
+      </p>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.unit {
+  /* La teinte de la barre. Locale : la portée n'est pas la teinte de la
+     section, qui appartient à l'en-tête. */
+  --unit-tone: var(--accent-cool);
+  border: 1px solid rgb(var(--line-default));
+  border-radius: var(--radius-sm);
+  background-color: rgb(var(--bg-inset));
+}
+.unit[data-pending='true'] .unit-val,
+.unit[data-pending='true'] .unit-chip-n { opacity: 0.55; }
+
+.unit-bar {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 0.35rem 1rem;
+  padding: 0.4rem 0.7rem;
+}
+
+/*
+ * Les paires. Une `<dl>` en grille à deux rangs : les libellés au-dessus des
+ * valeurs serait l'autre choix, mais la barre ferait deux fois la hauteur pour
+ * la même information — et elle est là en permanence.
+ */
+.unit-pairs {
+  display: flex;
+  align-items: baseline;
+  flex-wrap: wrap;
+  gap: 0.15rem 0.85rem;
+  margin: 0;
+  min-width: 0;
+}
+.unit-pair {
+  display: flex;
+  align-items: baseline;
+  gap: 0.35rem;
+  min-width: 0;
+}
+.unit-key {
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-muted));
+}
+.unit-val {
+  margin: 0 0.5rem 0 0.3rem;
+  font-size: 0.8125rem;
+  font-weight: 700;
+  color: rgb(var(--fg-strong));
+  white-space: nowrap;
+}
+/* La dernière valeur n'a pas de voisine à écarter. */
+.unit-val:last-child { margin-right: 0; }
+
+.unit-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.3rem;
+  margin-left: auto;
+  min-height: 1.75rem;
+  padding: 0 0.5rem;
+  font-family: var(--font-mono);
+  font-size: var(--label-md, 0.625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  white-space: nowrap;
+  color: rgb(var(--fg-muted));
+  background: transparent;
+  border: 1px solid rgb(var(--line-strong));
+  border-radius: var(--radius-xs);
+  cursor: pointer;
+  transition:
+    color var(--dur-1) var(--ease-standard),
+    border-color var(--dur-1) var(--ease-standard);
+}
+.unit-toggle:hover {
+  color: rgb(var(--fg-default));
+  border-color: rgb(var(--unit-tone));
+}
+
+.unit-panel {
+  display: flex;
+  flex-direction: column;
+  gap: 0.45rem;
+  padding: 0.55rem 0.7rem 0.6rem;
+  border-top: 1px solid rgb(var(--line-default));
+}
+
+/* Le libellé d'étage à largeur FIXE : les trois rangées de pastilles
+   commencent au même `x`, sinon les trois étages se lisent comme trois
+   listes sans rapport. */
+.unit-row {
+  display: grid;
+  grid-template-columns: 4.5rem minmax(0, 1fr);
+  align-items: start;
+  gap: 0.5rem;
+}
+.unit-row-key {
+  padding-top: 0.25rem;
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-faint));
+}
+.unit-chips {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.3rem;
+  min-width: 0;
+}
+
+/*
+ * La pastille active prend la paire pleine `--accent-warm` /
+ * `--accent-warm-fg`. `--accent-warm-text` posé sur un voile de la même
+ * teinte tombe sous 4,5:1 en thème clair, et c'est mesuré — le même arbitrage
+ * que le repère de version juste en dessous.
+ */
+.unit-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  min-height: 1.6rem;
+  padding: 0 0.45rem;
+  font-size: 0.6875rem;
+  font-weight: 600;
+  white-space: nowrap;
+  color: rgb(var(--fg-muted));
+  background: rgb(var(--bg-elevated));
+  border: 1px solid rgb(var(--line-strong));
+  border-radius: var(--radius-xs);
+  cursor: pointer;
+  transition:
+    color var(--dur-1) var(--ease-standard),
+    border-color var(--dur-1) var(--ease-standard),
+    background-color var(--dur-1) var(--ease-standard);
+}
+.unit-chip:hover {
+  color: rgb(var(--fg-default));
+  border-color: rgb(var(--unit-tone));
+}
+.unit-chip[aria-pressed='true'] {
+  background-color: rgb(var(--accent-warm));
+  border-color: rgb(var(--accent-warm));
+  color: rgb(var(--accent-warm-fg));
+}
+.unit-chip--ep {
+  font-family: var(--font-mono);
+  /* `E09` et `E10` côte à côte : sans chiffres tabulaires la colonne de
+     pastilles ondule. */
+  font-variant-numeric: tabular-nums;
+}
+.unit-chip-n {
+  font-family: var(--font-mono);
+  font-size: 0.5625rem;
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+  opacity: 0.75;
+}
+
+.unit-note {
+  margin: 0;
+  font-size: 0.65625rem;
+  line-height: 1.55;
+  color: rgb(var(--fg-faint));
+}
+.unit-home {
+  padding: 0;
+  font-size: inherit;
+  font-weight: 700;
+  color: rgb(var(--accent));
+  background: none;
+  border: 0;
+  cursor: pointer;
+  text-decoration: underline;
+}
+.unit-home:hover { color: rgb(var(--accent-hover)); }
+
+@media (max-width: 720px) {
+  /* Sous 720 px le libellé d'étage mangerait un tiers de la largeur des
+     pastilles ; il passe au-dessus. */
+  .unit-row {
+    grid-template-columns: minmax(0, 1fr);
+    gap: 0.2rem;
+  }
+  .unit-row-key { padding-top: 0; }
+  .unit-chip { min-height: 2rem; }
+  .unit-toggle { min-height: 2rem; }
+}
+</style>
diff --git a/apps/web/app/components/torrent/detail/VersionsTable.vue b/apps/web/app/components/torrent/detail/VersionsTable.vue
new file mode 100644
index 00000000..c26f60d5
--- /dev/null
+++ b/apps/web/app/components/torrent/detail/VersionsTable.vue
@@ -0,0 +1,899 @@
+<script setup lang="ts">
+/**
+ * « Laquelle de ces quatre je prends ? » — et de quoi, au fait.
+ *
+ * # Ce que la version précédente affirmait, et qui était faux
+ *
+ * Elle listait TOUTES les releases de l'œuvre, triées par taille, et posait
+ * trois rangs d'usage dessus : la plus grosse « Image max », la plus petite
+ * « Léger ». Deux pannes mesurées sur le catalogue :
+ *
+ *   1. Entre unités. La fiche de `Cats.Eye.S01` (`tmdb:tv/34114`) affichait
+ *      `Cats.Eye.S02` étiquetée « Image max » et `S01` « Léger » : la saison 2
+ *      présentée comme une meilleure variante de la saison 1. Deux contenus
+ *      différents. La requête partait sans `scope`, et sans `scope` l'API
+ *      répond `all` — les neuf releases de toutes les découpes confondues.
+ *   2. Dans l'unité. `Sousou.no.Frieren.S01.VOSTFR.1080p.WEB-DL` pèse
+ *      42,9 Gio et `…S01.MULTi.1080p.BluRay.x265.FLAC` 22,4 Gio : le rang par
+ *      taille couronnait le WEB-DL et traitait le BluRay de « Léger ». Les
+ *      deux sont en 1080p, c'est la SOURCE qui les sépare.
+ *
+ * # Les deux moitiés du correctif
+ *
+ * `assignVersionMarkers` remplace le rang par des repères qui sont des
+ * PROPRIÉTÉS (voir son en-tête), et il suppose que la liste qu'on lui donne
+ * est une seule unité. Ce composant est l'autre moitié : il BORNE l'unité, et
+ * `VersionUnitBar` la NOMME.
+ *
+ * Borner, concrètement, c'est envoyer une portée. `season`/`episode` de la
+ * release affichée déterminent laquelle sans aucune heuristique, parce que
+ * c'est exactement le prédicat SQL de `scopeWhere` :
+ *
+ *   saison + épisode → `episode`    (`season IS NOT NULL AND episode IS NOT NULL`)
+ *   saison seule     → `season`     (`season IS NOT NULL AND episode IS NULL`)
+ *   ni l'un ni l'autre, sur une série → `integral`  (`season IS NULL`)
+ *   ni l'un ni l'autre, ailleurs      → `all`  — un film n'a qu'une découpe
+ *
+ * La portée dérivée contient donc TOUJOURS la release affichée, ce qui garde
+ * la ligne « Ici » dans le tableau. Mesuré : `…S01E09` en portée `episode`
+ * avec `season=1&episode=9` rend les 4 versions de l'épisode 9 ; `Cats.Eye.S01`
+ * en portée `season` avec `season=1` rend 1 release, et le tableau cesse de
+ * mentir en ne comparant plus rien.
+ *
+ * # La géométrie
+ *
+ * Onze pistes à positions fixes, déclarées une seule fois : la résolution est
+ * TOUJOURS au même `x`. C'est ce qui permet de descendre une colonne sans lire
+ * un nom de fichier — et c'est aussi pourquoi un repère par ligne au plus,
+ * dans une fente de largeur fixe. Deux repères sur une ligne décaleraient tout
+ * ce qui suit.
+ *
+ * Le tri reste la taille décroissante : la colonne des tailles descend, ce qui
+ * se compare d'un coup en chiffres tabulaires. Ce n'est plus un classement
+ * puisque les repères ne se calculent plus dessus.
+ */
+import { formatSize } from '~/utils/format';
+import type { GroupScope, ScopeSummary } from '~/utils/groupScopes';
+import { releaseChips } from '~/utils/releaseChips';
+import { safeHttpUrl } from '~/utils/safeUrl';
+import {
+  assignVersionMarkers,
+  releaseGroup,
+  releaseTags,
+  type VersionMarker,
+} from '~/utils/versionMarkers';
+import type { EpisodeBucket, SeasonBucket } from './VersionUnitBar.vue';
+
+/** Une release telle que `/api/torrents/group` la renvoie. */
+export interface GroupRelease {
+  id: string | null;
+  infoHash: string;
+  name: string;
+  size: number;
+  seeders: number;
+  leechers: number;
+  createdAt: string | null;
+  remote: { detailUrl: string | null; peers: string[] } | null;
+}
+
+/** La charge utile d'une portée, dans la forme documentée par `group.get.ts`. */
+interface ScopePayload {
+  group: { scopes: ScopeSummary[]; defaultScope: GroupScope };
+  scope: GroupScope;
+  seasons: SeasonBucket[];
+  openSeason: number | null;
+  episodes: EpisodeBucket[];
+  episodesTruncated: boolean;
+  openEpisode: number | null;
+  releases: GroupRelease[];
+  releasesTruncated: boolean;
+}
+
+const props = withDefaults(
+  defineProps<{
+    /** `tmdb:tv/209867`, `igdb:…` — avec son préfixe, ce que le composable dérive. */
+    groupKey: string | null | undefined;
+    /** La release affichée, pour la marquer « ici » plutôt que de s'y renvoyer. */
+    currentInfoHash: string;
+    /** La position dans la série. C'est elle qui borne l'unité — voir l'en-tête. */
+    season?: number | null;
+    episode?: number | null;
+    /**
+     * Déjà chargées par l'appelant, et supposées être UNE unité. Fournies,
+     * aucune requête n'est faite et la barre d'unité ne se rend pas : sans
+     * réponse serveur il n'y a ni portée, ni saisons, ni rien à naviguer.
+     */
+    releases?: GroupRelease[] | null;
+    /** Au-delà, la fiche renvoie vers la page de groupe. */
+    limit?: number;
+  }>(),
+  { season: null, episode: null, releases: null, limit: 8 },
+);
+
+const { loggedIn } = useUserSession();
+const { locale } = useI18n();
+
+/* ── Borner l'unité ───────────────────────────────────────────────────────── */
+
+/**
+ * La découpe à laquelle la release affichée appartient.
+ *
+ * Le test `tmdb:tv/` n'est pas une devinette : la clé de groupe est construite
+ * en SQL comme `'tmdb:' || tmdb_id` et le découpage par saison teste
+ * `tmdb_id LIKE 'tv/%'`, donc le préfixe porte la même information des deux
+ * côtés. Compté sur le catalogue : 40 torrents en `tv/…`, 5 en identifiant nu
+ * (des films), ZÉRO en `movie/…`, et — le seul chiffre qui compte ici — zéro
+ * torrent portant une saison sans le préfixe `tv/`. Une série est donc toujours
+ * reconnue, et un identifiant nu est un film.
+ *
+ * Tout ce qui n'est pas une série n'a qu'une découpe, que l'API nomme `all`.
+ */
+const homeScope = computed<GroupScope>(() => {
+  if (props.season !== null && props.episode !== null) return 'episode';
+  if (props.season !== null) return 'season';
+  return props.groupKey?.startsWith('tmdb:tv/') ? 'integral' : 'all';
+});
+
+/** Ce qui est demandé au serveur. La réponse dit ce qui a été ouvert. */
+const wanted = ref<{
+  scope: GroupScope;
+  season: number | null;
+  episode: number | null;
+}>({
+  scope: homeScope.value,
+  season: props.season,
+  episode: props.episode,
+});
+
+// Changer de fiche sans démonter le composant remet l'unité de la nouvelle
+// release : `<NuxtLink>` entre deux torrents réutilise la page.
+watch(homeScope, (scope) => {
+  wanted.value = { scope, season: props.season, episode: props.episode };
+});
+
+function pick(next: {
+  scope: GroupScope;
+  season: number | null;
+  episode: number | null;
+}) {
+  wanted.value = next;
+}
+
+/* ── La requête, qui ne bloque pas le rendu ───────────────────────────────── */
+
+/**
+ * `lazy` et conditionnelle. La route exige une session : la lancer pour un
+ * visiteur anonyme renverrait un 401 et rendrait une section en erreur là où
+ * il n'y a rien à dire. Et `immediate: false` sans clé de groupe — une release
+ * sans identifiant externe n'a pas d'œuvre à laquelle se rattacher.
+ */
+const shouldFetch = computed(
+  () => !props.releases && !!props.groupKey && loggedIn.value,
+);
+
+/*
+ * Sans `await`. `await useFetch()` au niveau du `setup` rend la composante
+ * asynchrone et fait attendre le rendu de la page qui la contient — l'erreur
+ * que le composable de la fiche a justement corrigée. `lazy` veut dire « la
+ * section se rend vide puis se remplit », ce qui n'a de sens que si personne
+ * n'attend.
+ *
+ * La `query` est réactive, donc changer d'unité recharge tout seul : c'est le
+ * `watch` que `useAsyncData` installe sur les sources réactives de la clé, et
+ * il tourne même sous `immediate: false`.
+ */
+const { data, pending } = useFetch<ScopePayload>('/api/torrents/group', {
+  query: computed(() => ({
+    key: props.groupKey ?? '',
+    scope: wanted.value.scope,
+    ...(wanted.value.season !== null ? { season: wanted.value.season } : {}),
+    ...(wanted.value.episode !== null ? { episode: wanted.value.episode } : {}),
+  })),
+  lazy: true,
+  immediate: shouldFetch.value,
+});
+
+/*
+ * L'unité OUVERTE se lit dans la réponse, jamais dans `wanted`.
+ *
+ * Sans `season`, le serveur ouvre le seau le plus récent et le dit dans
+ * `openSeason` ; recopier ce choix dans `wanted` changerait la clé de requête
+ * et déclencherait un deuxième aller-retour pour la même réponse. Les deux
+ * états sont donc distincts : `wanted` est la demande, la réponse est la
+ * vérité, et la barre d'unité surligne la seconde.
+ */
+const payload = computed(() => data.value ?? null);
+const scope = computed<GroupScope>(() => payload.value?.scope ?? wanted.value.scope);
+const scopes = computed<ScopeSummary[]>(() => payload.value?.group?.scopes ?? []);
+const openSeason = computed(() => payload.value?.openSeason ?? null);
+const openEpisode = computed(() => payload.value?.openEpisode ?? null);
+
+/* ── Les repères ──────────────────────────────────────────────────────────── */
+
+interface VersionRow {
+  key: string;
+  name: string;
+  size: number;
+  seeders: number;
+  marker: VersionMarker | null;
+  current: boolean;
+  /** Route interne, ou `null` pour une release que seul un partenaire détient. */
+  to: string | null;
+  /** L'URL du partenaire, déjà filtrée. */
+  href: string | null;
+  cells: {
+    language: string | null;
+    resolution: string | null;
+    source: string | null;
+    codec: string | null;
+    group: string | null;
+  };
+  /**
+   * Par axe de qualité, « diffère de la release affichée ». `null` sur la
+   * release affichée elle-même — elle est le référent, pas un terme — et sur
+   * toutes les lignes quand le référent n'est pas dans le tableau.
+   */
+  diff: Record<DiffAxis, boolean> | null;
+}
+
+/** Les axes que le tableau compare. Le groupe est un nom, pas une qualité. */
+type DiffAxis = 'language' | 'resolution' | 'source' | 'codec';
+const DIFF_AXES: readonly DiffAxis[] = ['language', 'resolution', 'source', 'codec'];
+
+const unit = computed<GroupRelease[]>(
+  () => props.releases ?? payload.value?.releases ?? [],
+);
+
+/**
+ * Une seule unité ?
+ *
+ * `all` est la seule portée qui mélange : sur une série elle rend S01, S02 et
+ * l'intégrale ensemble, ce qui EST la panne de Cats.Eye. Elle n'est une unité
+ * que lorsque l'œuvre n'a AUCUNE autre découpe — un film, un jeu, un livre,
+ * dont `group.scopes` vaut exactement `[{ scope: 'all' }]`.
+ *
+ * « Une seule entrée dans `scopes` » serait le mauvais test, et c'est mesuré :
+ * `tmdb:tv/34114` (Cats.Eye) répond `scopes: [{ season: 2 }]` — une entrée,
+ * deux saisons. En portée `all` il rend S01 et S02 ensemble, et le garde-fou
+ * les aurait laissées se comparer.
+ *
+ * Les pastilles de portée ne proposent que `group.scopes`, donc `all` n'est pas
+ * atteignable au clic sur une série ; le garde-fou tient pour la portée
+ * INITIALE et pour un futur appelant qui rouvrirait le cas sans le voir.
+ */
+const bounded = computed(() => {
+  if (props.releases) return true;
+  if (scope.value !== 'all') return true;
+  return scopes.value.every((s) => s.scope === 'all');
+});
+
+const rows = computed<VersionRow[]>(() => {
+  const sorted = [...unit.value].sort((a, b) => b.size - a.size);
+  /*
+   * Les repères sur l'unité ENTIÈRE, puis la coupe à `limit`. `light` est un
+   * extremum : le calculer sur les huit premières lignes désignerait la plus
+   * petite des huit, pas la plus petite de l'unité. Un repère qui tombe hors
+   * de la vue est honnête ; un repère faux ne l'est pas.
+   */
+  const markers = bounded.value
+    ? assignVersionMarkers(
+        sorted.map((r) => ({ size: r.size, tags: releaseTags(r.name) })),
+      )
+    : sorted.map(() => null);
+
+  const shown = sorted.slice(0, props.limit).map((r, i) => {
+    const c = releaseChips(r.name);
+    const url = r.id ? null : safeHttpUrl(r.remote?.detailUrl);
+    return {
+      key: r.infoHash || r.name,
+      name: r.name,
+      size: r.size,
+      seeders: r.seeders,
+      marker: markers[i] ?? null,
+      current: r.infoHash.toLowerCase() === props.currentInfoHash.toLowerCase(),
+      to: r.id ? `/torrents/${r.infoHash}` : null,
+      href: url,
+      cells: {
+        language: c.language,
+        resolution: c.resolution,
+        source: c.source,
+        codec: c.codec,
+        group: releaseGroup(r.name),
+      },
+      diff: null as VersionRow['diff'],
+    };
+  });
+
+  /*
+   * Ce qui CHANGE, plutôt que tout en gris. Sur l'épisode 9 de Frieren, les
+   * quatre versions sont en 1080p WEB-DL x264 : trois colonnes identiques sur
+   * quatre lignes, et la seule qui décide — la langue — écrite comme les
+   * autres. Le référent est la release affichée ; deux valeurs absentes sont
+   * « pareilles », une absente contre une présente est une différence.
+   */
+  const ref = shown.find((r) => r.current);
+  if (ref) {
+    const norm = (v: string | null) => (v ?? '').toLowerCase();
+    for (const row of shown) {
+      if (row.current) continue;
+      row.diff = Object.fromEntries(
+        DIFF_AXES.map((a) => [a, norm(row.cells[a]) !== norm(ref.cells[a])]),
+      ) as Record<DiffAxis, boolean>;
+    }
+  }
+  return shown;
+});
+
+/** La légende « souligné » n'a de sens que si une ligne au moins compare. */
+const hasDiff = computed(() => rows.value.some((r) => r.diff));
+
+/**
+ * Les classes d'une cellule comparée : `--diff` ou `--same` quand une ligne
+ * compare, et `--none` sur une valeur absente — le tiret reste en graisse s'il
+ * marque une différence, mais ne se souligne pas : un tiret souligné se lit
+ * comme un signe égal.
+ */
+const diffClass = (row: VersionRow, axis: DiffAxis) => [
+  row.diff ? (row.diff[axis] ? 'ver-c--diff' : 'ver-c--same') : null,
+  row.cells[axis] === null ? 'ver-c--none' : null,
+];
+
+/**
+ * Se rend dès qu'il y a quelque chose à arbitrer OU à naviguer.
+ *
+ * Le seuil n'est plus « deux releases » : borner l'unité fait tomber
+ * `Cats.Eye.S01` à une seule version, et masquer la section priverait alors du
+ * seul chemin vers la saison 2. Une ligne unique plus une barre qui offre
+ * `Saison 02 · 1 release` est utile, et elle n'affirme rien —
+ * `assignVersionMarkers` ne pose aucun repère sur une version seule.
+ */
+const navigable = computed(() => {
+  if (scopes.value.length > 1) return true;
+  const p = payload.value;
+  return !!p && (p.seasons.length > 1 || p.episodes.length > 1);
+});
+const show = computed(() => rows.value.length > 1 || navigable.value);
+
+const hasCurrent = computed(() => rows.value.some((r) => r.current));
+const hidden = computed(() => Math.max(0, unit.value.length - rows.value.length));
+
+/** Les repères présents ici : la légende n'explique que ce qui est affiché. */
+const shownMarkers = computed(() => {
+  const seen = new Set<VersionMarker>();
+  for (const r of rows.value) if (r.marker) seen.add(r.marker);
+  return [...seen];
+});
+
+const groupHref = computed(() =>
+  props.groupKey ? `/torrents/group/${props.groupKey}` : null,
+);
+
+const nf = computed(() => new Intl.NumberFormat(locale.value));
+
+/**
+ * Le nom découpé aux séparateurs, séparateur inclus dans le segment qui le
+ * précède — exactement ce que fait `IdentityCard`, et pour la même raison.
+ *
+ * Sous 768 px cette colonne passe en `overflow-wrap: anywhere`, qui coupe au
+ * MILIEU d'un mot : mesuré à 390 px, `…S01E09.MULTi…` devenait `MU` / `LTi` et
+ * `VOSTFR` devenait `VO` / `STFR`. Or ce tableau est le seul endroit de la
+ * page où l'on COMPARE des noms de release entre eux — c'est là que la coupe
+ * illisible coûte le plus cher, et c'est le seul des deux composants qui ne
+ * l'avait pas résolue.
+ *
+ * `overflow-wrap: anywhere` reste en place : avec les `<wbr>`, le navigateur
+ * se sert d'abord des points de coupe légitimes et ne tombe sur les autres
+ * que face à un segment qui ne tient toujours pas.
+ */
+const nameChunks = (name: string) => name.split(/(?<=[._-])/);
+</script>
+
+<template>
+  <section v-if="show" class="versions">
+    <SectionHead
+      :title="$t('torrents.detail.versions.title')"
+      :count="rows.length || null"
+      icon="ph:stack-bold"
+    >
+      <template #action>
+        <NuxtLink v-if="groupHref" :to="groupHref" class="versions-all">
+          {{ $t('torrents.detail.versions.allReleases') }}
+          <Icon name="ph:arrow-right-bold" aria-hidden="true" />
+        </NuxtLink>
+      </template>
+    </SectionHead>
+
+    <!-- L'unité, écrite en clair AVANT le tableau : c'est elle qui dit sur quoi
+         porte la comparaison, et son absence était la moitié de la panne. -->
+    <TorrentDetailVersionUnitBar
+      v-if="payload"
+      class="versions-unit"
+      :scope="scope"
+      :scopes="scopes"
+      :seasons="payload.seasons"
+      :open-season="openSeason"
+      :episodes="payload.episodes"
+      :open-episode="openEpisode"
+      :episodes-truncated="payload.episodesTruncated"
+      :home-scope="homeScope"
+      :home-season="season"
+      :home-episode="episode"
+      :pending="pending"
+      @pick="pick"
+    />
+
+    <div class="versions-card">
+      <!--
+        L'en-tête de colonnes est un repère VISUEL : `aria-hidden`, parce que
+        six jetons courts annoncés après huit intitulés sans association de
+        cellule n'apportent rien à un lecteur d'écran, alors que le lien de
+        chaque ligne porte déjà le nom complet de la release.
+      -->
+      <div class="ver-row ver-row--head" aria-hidden="true">
+        <span class="ver-mk" />
+        <span class="ver-badge ver-badge--empty" />
+        <span class="ver-c ver-lang">{{ $t('torrents.detail.versions.col.language') }}</span>
+        <span class="ver-c ver-res">{{ $t('torrents.detail.versions.col.resolution') }}</span>
+        <span class="ver-c ver-src">{{ $t('torrents.detail.versions.col.source') }}</span>
+        <span class="ver-c ver-cod">{{ $t('torrents.detail.versions.col.codec') }}</span>
+        <span class="ver-c ver-grp">{{ $t('torrents.detail.versions.col.group') }}</span>
+        <span class="ver-name">{{ $t('torrents.detail.versions.col.name') }}</span>
+        <span class="ver-size">{{ $t('torrents.detail.versions.col.size') }}</span>
+        <span class="ver-seed">{{ $t('torrents.detail.versions.col.seeders') }}</span>
+        <span class="ver-act" />
+      </div>
+
+      <!-- Changer d'unité remplace les lignes : elles se fondent et
+           descendent en place plutôt que de sauter. Rien au premier rendu. -->
+      <TransitionGroup tag="div" name="ver" class="ver-rows">
+      <div
+        v-for="row in rows"
+        :key="row.key"
+        class="ver-row"
+        :data-current="row.current ? 'true' : 'false'"
+      >
+        <span class="ver-mk" aria-hidden="true" />
+
+        <!-- Un repère par ligne au plus, dans une fente de largeur fixe : deux
+             repères décaleraient toutes les colonnes suivantes. -->
+        <span
+          v-if="row.marker"
+          class="ver-badge"
+          :data-marker="row.marker"
+          :title="$t(`torrents.detail.versions.marker.${row.marker}Hint`)"
+        >
+          {{ $t(`torrents.detail.versions.marker.${row.marker}`) }}
+        </span>
+        <span v-else class="ver-badge ver-badge--empty" aria-hidden="true" />
+
+        <span class="ver-c ver-lang" :class="diffClass(row, 'language')">{{ row.cells.language ?? '—' }}</span>
+        <span class="ver-c ver-res" :class="diffClass(row, 'resolution')">{{ row.cells.resolution ?? '—' }}</span>
+        <span class="ver-c ver-src" :class="diffClass(row, 'source')">{{ row.cells.source ?? '—' }}</span>
+        <span class="ver-c ver-cod" :class="diffClass(row, 'codec')">{{ row.cells.codec ?? '—' }}</span>
+        <span class="ver-c ver-grp" :title="row.cells.group ?? undefined">{{
+          row.cells.group ?? '—'
+        }}</span>
+
+        <span class="ver-name" :title="row.name"><template
+          v-for="(chunk, ci) in nameChunks(row.name)"
+          :key="ci"
+        >{{ chunk }}<wbr></template></span>
+
+        <span class="ver-size">{{ formatSize(row.size) }}</span>
+
+        <!-- Le même chevron que la carte de décision, pas une lettre : « 0 S »
+             sans en-tête de colonne (masqué sous 42 rem) ne se devinait pas. -->
+        <span class="ver-seed">
+          <Icon name="ph:caret-up-fill" class="ver-seed-i" aria-hidden="true" />{{ nf.format(row.seeders) }}
+          <span class="sr-only">{{ $t('torrents.detail.stats.seeders') }}</span>
+        </span>
+
+        <span class="ver-act">
+          <!-- La release affichée ne se renvoie pas à elle-même : elle dit
+               qu'on y est. C'est le référent de la puce, expliqué en légende. -->
+          <span v-if="row.current" class="ver-here">
+            {{ $t('torrents.detail.versions.here') }}
+          </span>
+          <NuxtLink
+            v-else-if="row.to"
+            :to="row.to"
+            class="tool-btn tool-btn--sm tool-btn--text ver-go"
+            :aria-label="$t('torrents.detail.versions.viewAria', { name: row.name })"
+          >
+            <span class="ver-go-txt">{{ $t('torrents.detail.versions.view') }}</span>
+            <Icon name="ph:arrow-right-bold" aria-hidden="true" />
+          </NuxtLink>
+          <!-- Chez un partenaire seulement : lien externe, jamais une route
+               locale qui rendrait un 404. -->
+          <a
+            v-else-if="row.href"
+            :href="row.href"
+            target="_blank"
+            rel="noopener noreferrer"
+            class="tool-btn tool-btn--sm tool-btn--text ver-go"
+            :aria-label="$t('torrents.detail.versions.viewPartnerAria', { name: row.name })"
+          >
+            <span class="ver-go-txt">{{ $t('torrents.detail.versions.viewPartner') }}</span>
+            <Icon name="ph:arrow-square-out" aria-hidden="true" />
+          </a>
+          <span v-else class="ver-none" aria-hidden="true">—</span>
+        </span>
+      </div>
+      </TransitionGroup>
+
+      <!-- La légende n'explique que les repères RÉELLEMENT posés : « Compat »
+           décrit dans une unité qui n'en a aucun est du bruit. -->
+      <div class="ver-legend">
+        <span v-if="hasCurrent" class="ver-legend-item">
+          <span class="ver-legend-dot" aria-hidden="true" />
+          {{ $t('torrents.detail.versions.legend.current') }}
+        </span>
+        <span v-if="hasDiff" class="ver-legend-item">
+          <u class="ver-legend-u">{{ $t('torrents.detail.versions.legend.diffMark') }}</u>
+          {{ $t('torrents.detail.versions.legend.diff') }}
+        </span>
+        <span v-for="m in shownMarkers" :key="m" class="ver-legend-item">
+          <b class="ver-legend-tag">{{ $t(`torrents.detail.versions.marker.${m}`) }}</b>
+          {{ $t(`torrents.detail.versions.marker.${m}Hint`) }}
+        </span>
+        <span class="ver-legend-item">{{ $t('torrents.detail.versions.legend.unit') }}</span>
+        <span v-if="payload?.releasesTruncated" class="ver-legend-item">
+          {{ $t('search.group.truncated') }}
+        </span>
+        <NuxtLink v-if="hidden && groupHref" :to="groupHref" class="ver-legend-more">
+          {{ $t('torrents.detail.versions.legend.more', { n: hidden }) }}
+        </NuxtLink>
+      </div>
+    </div>
+  </section>
+</template>
+
+<style scoped>
+/*
+ * Les points de rupture de ce tableau se mesurent sur SA largeur, plus sur
+ * celle de la fenêtre. Depuis que la fiche est en deux colonnes, il vit dans
+ * une colonne de lecture de 836 px à 1280 px de fenêtre — et la requête
+ * `@media (max-width: 1180px)` le croyait pleine largeur : onze colonnes,
+ * 710 px de colonnes fixes, une centaine de pixels pour le nom, qui se cassait
+ * à chaque séparateur sur six lignes. Une requête de conteneur regarde la
+ * place réelle, ici comme partout où le composant sera posé.
+ */
+.versions {
+  container-type: inline-size;
+  container-name: versions;
+}
+.versions-all {
+  /* WCAG 2.5.8 : 24 px CSS au minimum pour une cible de pointeur, et ceci
+     n'est pas un lien DANS une phrase, donc la dérogation « inline » ne
+     s'applique pas. Mesuré à 17 px avant. La hauteur seule change ; le texte
+     reste où il est. */
+  min-height: 1.5rem;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.3rem;
+  font-family: var(--font-mono);
+  font-size: var(--label-lg, 0.6875rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  text-decoration: none;
+  color: rgb(var(--fg-muted));
+  white-space: nowrap;
+  transition: color var(--dur-2) ease;
+}
+.versions-all:hover { color: rgb(var(--accent)); }
+
+.versions-unit { margin-bottom: 0.5rem; }
+
+.versions-card {
+  display: flex;
+  flex-direction: column;
+  background: rgb(var(--bg-elevated));
+  border: 1px solid rgb(var(--line-strong));
+  border-radius: var(--radius-md);
+  overflow: hidden;
+}
+
+/*
+ * Les positions fixes. Chaque piste est déclarée une fois, donc le `x` d'une
+ * colonne est le même sur toutes les lignes au dixième de pixel près — c'est
+ * une grille, pas un flex qui recalcule ligne par ligne. L'en-tête de colonnes
+ * réutilise EXACTEMENT la même règle : deux déclarations dériveraient.
+ */
+.ver-row {
+  display: grid;
+  align-items: center;
+  gap: 0.15rem 0.5rem;
+  grid-template-columns:
+    0.75rem 5rem
+    3.4rem 3.2rem 4.4rem 3.4rem 5rem
+    minmax(0, 1fr) 5.4rem 4.2rem 4.6rem;
+  grid-template-areas: 'mk badge lang res src cod grp name size seed act';
+  min-height: 2.5rem;
+  padding: 0.3rem 0.85rem;
+  transition: background-color var(--dur-1) var(--ease-standard);
+}
+.ver-row + .ver-row { border-top: 1px solid rgb(var(--line-default)); }
+.ver-rows { position: relative; }
+.ver-enter-active { transition: opacity var(--dur-4) var(--ease-emphasis), transform var(--dur-4) var(--ease-emphasis); }
+.ver-enter-from { opacity: 0; transform: translateY(0.3rem); }
+/* La sortie est plus courte que l'entrée, et hors du flux pour que les
+   nouvelles lignes prennent leur place tout de suite. */
+.ver-leave-active { position: absolute; width: 100%; transition: opacity var(--dur-2) var(--ease-standard); }
+.ver-leave-to { opacity: 0; }
+.ver-move { transition: transform var(--dur-3) var(--ease-standard); }
+.ver-row:hover { background-color: rgb(var(--bg-hover)); }
+.ver-row[data-current='true'] { background-color: rgb(var(--accent-warm) / 0.07); }
+
+/* L'en-tête nomme les colonnes sans se faire passer pour une ligne : pas de
+   survol, une hauteur réduite, et le fond en creux du conteneur. */
+.ver-row--head {
+  min-height: 1.9rem;
+  background-color: rgb(var(--bg-inset));
+  border-bottom: 1px solid rgb(var(--line-strong));
+}
+.ver-row--head:hover { background-color: rgb(var(--bg-inset)); }
+.ver-row--head .ver-c,
+.ver-row--head .ver-name,
+.ver-row--head .ver-size,
+.ver-row--head .ver-seed {
+  font-family: var(--font-mono);
+  font-size: var(--label-sm, 0.5625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking-wide, calc(0.16em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--fg-faint));
+}
+
+.ver-mk {
+  grid-area: mk;
+  justify-self: center;
+  width: 0.5rem;
+  height: 0.5rem;
+  border-radius: var(--radius-pill);
+  border: 1px solid rgb(var(--line-field));
+}
+.ver-row--head .ver-mk { border-color: transparent; }
+.ver-row[data-current='true'] .ver-mk {
+  background-color: rgb(var(--accent-warm));
+  border-color: rgb(var(--accent-warm));
+}
+
+/*
+ * Le repère. UNE seule apparence pour les quatre.
+ *
+ * Quatre teintes, ou une pleine pour « Image max » et trois discrètes pour le
+ * reste, se reliraient comme quatre niveaux — c'est-à-dire comme le classement
+ * que ce fichier existe pour supprimer. Les quatre nomment des propriétés
+ * différentes, aucune n'est meilleure, donc aucune n'est plus voyante.
+ *
+ * Contour plutôt que fond plein : le texte reste `--fg-default` sur le fond de
+ * la carte, et la bordure `--accent-warm` est un élément NON textuel, qui
+ * relève des 3:1 de WCAG 1.4.11 — mesuré à 3,05:1 au pire des deux thèmes. La
+ * paire `--accent-warm-text` sur un voile de la même teinte, elle, tombe sous
+ * les 4,5:1 d'un texte en thème clair, et c'est pourquoi elle n'est pas ici.
+ */
+.ver-badge {
+  grid-area: badge;
+  justify-self: start;
+  display: inline-flex;
+  align-items: center;
+  height: 1.3rem;
+  padding: 0 0.4rem;
+  font-size: 0.625rem;
+  font-weight: 700;
+  letter-spacing: calc(0.04em * var(--tracking-scale));
+  white-space: nowrap;
+  border: 1px solid rgb(var(--accent-warm) / 0.55);
+  border-radius: var(--radius-sm);
+  color: rgb(var(--fg-default));
+  cursor: help;
+}
+.ver-badge--empty {
+  border-color: transparent;
+  cursor: auto;
+}
+
+.ver-c {
+  font-size: 0.6875rem;
+  color: rgb(var(--fg-muted));
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.ver-lang { grid-area: lang; font-weight: 700; color: rgb(var(--fg-default)); }
+.ver-res { grid-area: res; font-weight: 600; color: rgb(var(--fg-default)); }
+.ver-src { grid-area: src; }
+.ver-cod { grid-area: cod; }
+/* Le groupe de release est un nom propre : en monospace il se compare
+   caractère par caractère, ce que la colonne sert à faire. */
+.ver-grp {
+  grid-area: grp;
+  font-family: var(--font-mono);
+  font-size: 0.65625rem;
+}
+.ver-row--head .ver-grp { font-size: 0.5625rem; }
+
+/*
+ * La comparaison. Ce qui est pareil que la release affichée recule — même
+ * couleur qu'aujourd'hui, mais plus de graisse, donc toujours lisible (le
+ * `--fg-faint` des en-têtes tomberait sous 4,5:1 à cette taille). Ce qui
+ * diffère avance : graisse, `--fg-strong`, et un soulignement — un indice qui
+ * n'est pas une couleur, pour WCAG 1.4.1 et pour la légende qui le nomme.
+ */
+.ver-c--same {
+  font-weight: 400;
+  color: rgb(var(--fg-muted));
+}
+.ver-c--diff {
+  font-weight: 700;
+  color: rgb(var(--fg-strong));
+  text-decoration: underline;
+  text-decoration-color: rgb(var(--accent-warm) / 0.75);
+  text-decoration-thickness: 1.5px;
+  text-underline-offset: 0.18em;
+}
+.ver-c--diff.ver-c--none { text-decoration: none; }
+.ver-legend-u {
+  text-decoration-color: rgb(var(--accent-warm) / 0.75);
+  text-decoration-thickness: 1.5px;
+  text-underline-offset: 0.18em;
+  font-weight: 700;
+  color: rgb(var(--fg-default));
+}
+
+.ver-name {
+  grid-area: name;
+  min-width: 0;
+  font-family: var(--font-mono);
+  font-size: 0.71875rem;
+  color: rgb(var(--fg-muted));
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+.ver-row[data-current='true'] .ver-name { color: rgb(var(--fg-default)); }
+
+/* Les deux colonnes que l'œil compare : chiffres tabulaires, alignées à
+   droite. Sans `tabular-nums`, un « 1 » étroit décale la virgule d'une ligne à
+   l'autre et la comparaison ne se fait plus d'un coup d'œil. */
+.ver-size {
+  grid-area: size;
+  text-align: right;
+  font-size: 0.75rem;
+  font-weight: 700;
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+  color: rgb(var(--fg-default));
+}
+.ver-seed {
+  grid-area: seed;
+  text-align: right;
+  font-size: 0.75rem;
+  font-weight: 700;
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+  color: rgb(var(--fg-default));
+}
+.ver-seed-i {
+  font-size: 0.6rem;
+  margin-right: 0.15rem;
+  vertical-align: 0.05em;
+  color: rgb(var(--online));
+}
+
+.ver-act { grid-area: act; justify-self: end; }
+.ver-go { font-size: 0.6875rem; text-decoration: none; }
+.ver-here {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-height: 2rem;
+  padding: 0 0.5rem;
+  font-size: var(--label-md, 0.625rem);
+  font-weight: var(--label-weight, 700);
+  letter-spacing: var(--label-tracking, calc(0.08em * var(--tracking-scale)));
+  text-transform: uppercase;
+  color: rgb(var(--accent-warm-text));
+}
+.ver-none { color: rgb(var(--fg-muted)); }
+
+.ver-legend {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.25rem 0.9rem;
+  padding: 0.35rem 0.85rem;
+  border-top: 1px solid rgb(var(--line-default));
+  font-size: 0.65625rem;
+  line-height: 1.5;
+  color: rgb(var(--fg-muted));
+}
+.ver-legend-item {
+  display: inline-flex;
+  align-items: baseline;
+  gap: 0.3rem;
+}
+.ver-legend-tag {
+  font-weight: 700;
+  color: rgb(var(--fg-default));
+  white-space: nowrap;
+}
+.ver-legend-dot {
+  align-self: center;
+  width: 0.5rem;
+  height: 0.5rem;
+  border-radius: var(--radius-pill);
+  background-color: rgb(var(--accent-warm));
+}
+.ver-legend-more {
+  color: rgb(var(--fg-default));
+  font-weight: 600;
+  text-decoration: none;
+}
+.ver-legend-more:hover { color: rgb(var(--accent)); }
+
+/* ── Tablette : le codec et le nom partent, les colonnes restent alignées ─── */
+@container versions (max-width: 68rem) {
+  .ver-row {
+    grid-template-columns:
+      0.75rem 5rem
+      3.4rem 3.2rem 4.4rem 5rem
+      minmax(0, 1fr) 5.4rem 4.2rem 2.6rem;
+    grid-template-areas: 'mk badge lang res src grp name size seed act';
+  }
+  .ver-cod { display: none; }
+  .ver-go-txt { display: none; }
+  .ver-go { width: 2rem; padding: 0; justify-content: center; }
+}
+@container versions (max-width: 56rem) {
+  /* Le nom part avant les jetons : langue + résolution + source + groupe
+     identifient la release, le nom ne fait que les répéter en plus long. */
+  .ver-row {
+    grid-template-columns:
+      0.75rem 5rem
+      3.4rem 3.2rem 4.4rem minmax(0, 5rem)
+      5.4rem 4.2rem 2.6rem;
+    grid-template-areas: 'mk badge lang res src grp size seed act';
+  }
+  .ver-name { display: none; }
+}
+
+/* ── Mobile : la grille se casse en étages plutôt que de comprimer neuf
+      colonnes dans 360 px ──────────────────────────────────────────────────── */
+@container versions (max-width: 42rem) {
+  .ver-row {
+    grid-template-columns: 0.75rem minmax(0, 1fr) auto 2.75rem;
+    grid-template-areas:
+      'mk name name act'
+      'mk badge size seed'
+      'mk lang res src';
+    gap: 0.25rem 0.5rem;
+    padding: 0.55rem 0.85rem;
+  }
+  /* Un en-tête de colonnes n'a plus de sens quand la ligne fait trois étages :
+     les intitulés ne surplomberaient plus rien. */
+  .ver-row--head { display: none; }
+  .ver-name {
+    display: block;
+    white-space: normal;
+    overflow-wrap: anywhere;
+    text-overflow: clip;
+  }
+  .ver-grp { display: none; }
+  .ver-lang,
+  .ver-res,
+  .ver-src { justify-self: start; }
+  .ver-size { text-align: left; }
+  .ver-seed { text-align: left; }
+  .ver-mk { align-self: start; margin-top: 0.45rem; }
+  .ver-act { align-self: start; }
+  .ver-go { width: 2.75rem; height: 2.75rem; }
+  .ver-here { min-height: 2.75rem; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .ver-enter-active,
+  .ver-leave-active,
+  .ver-move { transition: none; }
+}
+</style>
diff --git a/apps/web/app/composables/useAdminNav.ts b/apps/web/app/composables/useAdminNav.ts
index 3dd5c07c..6b9a9a91 100644
--- a/apps/web/app/composables/useAdminNav.ts
+++ b/apps/web/app/composables/useAdminNav.ts
@@ -137,6 +137,12 @@ export function useAdminNav() {
           icon: 'ph:folders',
           description: t('admin.descriptions.categories'),
         },
+        {
+          label: t('admin.nav.searchMisses'),
+          path: '/admin/search-misses',
+          icon: 'ph:magnifying-glass-minus',
+          description: t('admin.descriptions.searchMisses'),
+        },
         {
           label: t('admin.nav.tags'),
           path: '/admin/tags',
diff --git a/apps/web/app/composables/useBranding.ts b/apps/web/app/composables/useBranding.ts
index 65447027..7b130ac5 100644
--- a/apps/web/app/composables/useBranding.ts
+++ b/apps/web/app/composables/useBranding.ts
@@ -23,6 +23,13 @@ export interface BrandingPayload {
   pageTitleSuffix: string | null;
   /** Gates the federation nav items. False when federation was never set up. */
   federationEnabled: boolean;
+  /** Les réglages du catalogue choisis par l'opérateur (voir `getCatalogueSettings`). */
+  catalogue?: {
+    defaultView: 'grouped' | 'simple';
+    defaultSort: 'auto' | 'age' | 'name' | 'size' | 'seeders' | 'leechers' | 'completed';
+    pageSize: number;
+    facets: string[];
+  };
   /**
    * The theme every anonymous visitor and every new member starts on.
    *
@@ -53,8 +60,27 @@ export interface BrandingPayload {
   }>;
 }
 
+/**
+ * Le même état partagé, sans requête et sans `await`.
+ *
+ * `useBranding()` est asynchrone, et une fonction asynchrone qui n'est PAS un
+ * `<script setup>` perd le contexte Nuxt à son premier `await` : tout appel de
+ * composable qui suit lève `NUXT_E1001` au rendu serveur, et seulement là — le
+ * client a un `nuxtApp` global de repli, donc le défaut est invisible en
+ * navigation côté client comme au typecheck. Le compilateur de Vue enveloppe
+ * les `await` de premier niveau d'un `<script setup>` (`withAsyncContext`) et
+ * rétablit l'instance ; un fichier `.ts` n'a pas ce filet.
+ *
+ * Un appelant qui a seulement besoin de LIRE la charge — parce que le layout
+ * l'a déjà chargée, sur chaque page, avant que le setup de la page ne tourne —
+ * prend celui-ci et reste synchrone.
+ */
+export function useBrandingState() {
+  return useState<BrandingPayload | null>('branding', () => null);
+}
+
 export async function useBranding() {
-  const cached = useState<BrandingPayload | null>('branding', () => null);
+  const cached = useBrandingState();
 
   /**
    * Which session the cache was built for.
diff --git a/apps/web/app/composables/useDetailDisclosure.ts b/apps/web/app/composables/useDetailDisclosure.ts
new file mode 100644
index 00000000..db1c6a65
--- /dev/null
+++ b/apps/web/app/composables/useDetailDisclosure.ts
@@ -0,0 +1,61 @@
+/**
+ * Un repli, et la case qui les ouvre tous.
+ *
+ * # Pourquoi une case globale existe
+ *
+ * Replier le NFO, les pistes et les fichiers fait passer le bas de page de
+ * ~2000 px à 60 px — c'est la mesure qui a décidé la maquette. Mais un contenu
+ * en `display: none` est invisible pour le `Ctrl+F` du navigateur, et une fiche
+ * dont la recherche du navigateur ne trouve plus que le tiers visible est une
+ * régression pour qui vit au `Ctrl+F`.
+ *
+ * On ne peut pas intercepter la recherche du navigateur. La contre-mesure est
+ * donc une case unique : elle déplie TOUTES les sections d'un coup, et la
+ * recherche retrouve 100 % du contenu. C'est le compromis de `mockup-tabs`,
+ * transplanté ici.
+ *
+ * # Pourquoi `useState` et pas un `provide`
+ *
+ * Un `provide/inject` obligerait la page à envelopper ses sections dans un
+ * fournisseur — donc à connaître le mécanisme. Ici la page pose la case où elle
+ * veut, chaque repli lit le même état, et rien ne les relie dans le gabarit.
+ * `useState` plutôt qu'un `ref` de module : le rendu serveur a besoin que
+ * l'état soit sérialisé avec la page, sinon la première hydratation replie ce
+ * que le serveur avait déplié.
+ */
+
+import type { ComputedRef } from 'vue';
+
+/** L'état partagé : « tout est déplié ». */
+export function useExpandAll() {
+  return useState<boolean>('torrent-detail-expand-all', () => false);
+}
+
+export interface DisclosureState {
+  /** Ouvert — soit par son propre bouton, soit parce que tout est déplié. */
+  open: ComputedRef<boolean>;
+  /** Ce que le bouton du repli appelle. Sans effet quand tout est déplié. */
+  toggle: () => void;
+  /** Vrai quand l'ouverture vient de la case globale : le bouton se désactive. */
+  forced: ComputedRef<boolean>;
+}
+
+/**
+ * Un repli qui obéit à la case globale.
+ *
+ * L'état local est conservé pendant que la case est cochée : la décocher rend à
+ * chaque section l'état où le membre l'avait laissée, plutôt que de tout
+ * refermer.
+ */
+export function useDetailDisclosure(defaultOpen = false): DisclosureState {
+  const expandAll = useExpandAll();
+  const local = ref(defaultOpen);
+
+  return {
+    open: computed(() => expandAll.value || local.value),
+    toggle: () => {
+      if (!expandAll.value) local.value = !local.value;
+    },
+    forced: computed(() => expandAll.value),
+  };
+}
diff --git a/apps/web/app/composables/useTorrentDetail.ts b/apps/web/app/composables/useTorrentDetail.ts
new file mode 100644
index 00000000..1862dd8d
--- /dev/null
+++ b/apps/web/app/composables/useTorrentDetail.ts
@@ -0,0 +1,522 @@
+/**
+ * Toutes les données de la page de détail d'un torrent, et ce qu'on en dérive.
+ *
+ * # Pourquoi ce fichier existe
+ *
+ * La page portait 813 lignes de `<script setup>` pour 907 lignes de gabarit.
+ * Rien n'y était testable : chaque permission, chaque libellé dérivé, chaque
+ * requête vivait dans le composant qui les affichait.
+ *
+ * # Ce qu'il corrige au passage
+ *
+ * La page faisait **sept `await` au niveau de `setup`**, et un commentaire y
+ * affirmait que les requêtes annexes étaient faites ainsi « so a slow signature
+ * lookup never blocks the page render ». C'était faux : `await useFetch()` au
+ * niveau de `setup` est *exactement* ce qui fait attendre le rendu serveur. Le
+ * premier octet partait après sept allers-retours.
+ *
+ * Ici, une seule requête bloque le rendu serveur — le détail, sans lequel il
+ * n'y a pas de page. Les autres sont `lazy: true` : le rendu serveur ne les
+ * attend pas, et chaque section dépendante se rend vide puis se remplit. C'est
+ * ce que le commentaire d'origine décrivait, enfin implémenté.
+ *
+ * # Pourquoi cette fonction est SYNCHRONE
+ *
+ * Elle a d'abord été écrite `async`, avec `await useFetch()` pour le détail
+ * puis les annexes derrière. Ça rendait **500** au rendu serveur, et seulement
+ * là : `NUXT_E1001`.
+ *
+ * Le compilateur de Vue enveloppe chaque `await` de premier niveau d'un
+ * `<script setup>` dans `withAsyncContext()`, qui rétablit l'instance du
+ * composant après la reprise. Un fichier `.ts` ordinaire n'a pas ce
+ * traitement : le premier `await` y perd le contexte Nuxt, et le `useFetch()`
+ * suivant lève. La page d'origine faisait ses sept `await` DANS son
+ * `<script setup>` — d'où sept allers-retours, mais aucune erreur.
+ *
+ * Rien n'est donc attendu ici. `useFetch` sans `lazy` fait déjà attendre le
+ * rendu par la frontière `<Suspense>` ; aucun code de `setup` n'a besoin de la
+ * valeur résolue, tout ce qui en dépend est un `computed`. Le typecheck et les
+ * tests unitaires ne pouvaient pas voir le défaut : le client a un `nuxtApp`
+ * global de repli, donc seul un rendu serveur réel le montre.
+ */
+import type { MediaMetadata } from '@trackarr/shared/media';
+
+export interface TorrentComment {
+  id: string;
+  content: string;
+  createdAt: string;
+  author: { id: string; username: string } | null;
+}
+
+export interface CrossSeedItem {
+  id: string;
+  infoHash: string;
+  name: string;
+  size: number;
+  moderationStatus: string;
+  createdAt: string;
+  category: { id: string; name: string; slug: string; type: string | null } | null;
+  uploader: { id: string; username: string } | null;
+}
+
+export interface FederatedCrossSeedItem {
+  id: string;
+  infoHash: string;
+  name: string;
+  size: number;
+  seeders: number;
+  leechers: number;
+  peerName: string;
+  detailUrl: string | null;
+  matchType: string;
+}
+
+export interface CrossSeedStats {
+  otherTorrentCount: number;
+  seederCount: number;
+  leecherCount: number;
+  uploadedShareBytes: string;
+  totalUploadedBytes: string;
+}
+
+/** Ce que le membre doit encore à CE torrent. Absent si jamais téléchargé. */
+export interface SeedObligation {
+  downloaded: boolean;
+  seedTime: number;
+  requiredSeedTime: number;
+  isHnr: boolean;
+  isExempt: boolean;
+  completedAt: string | null;
+}
+
+interface MediaMetadataResponse {
+  enabled: boolean;
+  found: boolean;
+  metadata: MediaMetadata | null;
+}
+
+export function useTorrentDetail(hash: string) {
+  const { user, loggedIn } = useUserSession();
+  const { locale } = useI18n();
+  /*
+   * Capturé SYNCHRONEMENT, avant tout `then`. C'est ce qui permet à `ready`
+   * plus bas de rappeler un `execute()` depuis une continuation de promesse :
+   * `runWithContext` rétablit l'instance que la continuation n'a plus.
+   */
+  const nuxtApp = useNuxtApp();
+
+  /* ── La seule requête bloquante ─────────────────────────────────────────── */
+  // Pas de `await` : voir l'en-tête. Sans `lazy`, `<Suspense>` attend cette
+  // requête avant de rendre, ce qui est exactement l'effet voulu.
+  const detail = useFetch<Record<string, any>>(`/api/torrents/${hash}`);
+  const { data: torrent, error, refresh: refreshTorrent } = detail;
+
+  /* ── Les annexes, qui ne bloquent plus rien ─────────────────────────────── */
+  const { data: crossSeeds } = useFetch<{ items: CrossSeedItem[]; total: number }>(
+    `/api/torrents/${hash}/cross-seeds`,
+    { lazy: true, default: () => ({ items: [], total: 0 }) },
+  );
+
+  const { data: supersessions, refresh: refreshSupersessions } = useFetch<{
+    supersededBy: {
+      infoHash: string;
+      name: string;
+      size: number;
+      at: string;
+      reason: string | null;
+    } | null;
+    supersedes: Array<{
+      infoHash: string;
+      name: string;
+      size: number;
+      supersedeReason: string | null;
+    }>;
+  }>(`/api/torrents/${hash}/supersessions`, {
+    lazy: true,
+    default: () => ({ supersededBy: null, supersedes: [] }),
+  });
+
+  const { data: crossSeedStats } = useFetch<CrossSeedStats>(
+    `/api/torrents/${hash}/cross-seed-stats`,
+    {
+      lazy: true,
+      default: () => ({
+        otherTorrentCount: 0,
+        seederCount: 0,
+        leecherCount: 0,
+        uploadedShareBytes: '0',
+        totalUploadedBytes: '0',
+      }),
+    },
+  );
+
+  // L'état partagé, pas `useBranding()` : le layout l'a déjà chargé avant que
+  // ce setup ne tourne, et `useBranding()` est asynchrone — l'attendre ici
+  // reproduirait le NUXT_E1001 décrit en tête de fichier.
+  const branding = useBrandingState();
+  const federationEnabled = computed(() => !!branding.value?.federationEnabled);
+
+  const { data: federatedCrossSeeds } = useFetch<{
+    items: FederatedCrossSeedItem[];
+    total: number;
+    availability: { releases: number; seeders: number; leechers: number };
+  }>(`/api/torrents/${hash}/cross-seeds-federated`, {
+    lazy: true,
+    // Une instance non fédérée n'a pas de partenaire : inutile de partir.
+    immediate: federationEnabled.value,
+    default: () => ({
+      items: [],
+      total: 0,
+      availability: { releases: 0, seeders: 0, leechers: 0 },
+    }),
+  });
+
+  /* ── L'obligation du membre, qui n'atteignait pas la page ───────────────── */
+  const { data: obligation, refresh: refreshObligation, execute: fetchObligation } = useFetch<SeedObligation | null>(
+    `/api/torrents/${hash}/my-obligation`,
+    { lazy: true, immediate: false, default: () => null },
+  );
+  /*
+   * Demandée seulement quand la fiche s'affiche pour de vrai.
+   *
+   * Les routes unitaires appliquent la visibilité du listing, où le contenu
+   * adulte est EXCLU, tandis que la fiche le GARDE derrière un voile (200, avec
+   * un écran dédié). Une page voilée n'a donc pas d'obligation à montrer, et la
+   * demander produisait un 404 à chaque visite. Le tir est repoussé jusqu'à ce
+   * que le torrent soit connu et non voilé.
+   */
+  watch(
+    () => [loggedIn.value, !!torrent.value, !!torrent.value?.gatedAdult] as const,
+    ([signedIn, loaded, isGated]) => {
+      if (signedIn && loaded && !isGated) void fetchObligation();
+    },
+    { immediate: true },
+  );
+
+  /* ── Permissions ────────────────────────────────────────────────────────── */
+  const isOwner = computed(
+    () => !!user.value && torrent.value?.uploaderId === user.value.id,
+  );
+  const isStaff = computed(
+    () => !!user.value && (user.value.isAdmin || user.value.isModerator),
+  );
+  const canEdit = computed(() => loggedIn.value && (isOwner.value || isStaff.value));
+  const canDelete = canEdit;
+  const canReport = computed(() => loggedIn.value && !!user.value);
+  const canFavorite = canReport;
+
+  /* ── Dérivés d'affichage ────────────────────────────────────────────────── */
+  const gated = computed(() => !!torrent.value?.gatedAdult);
+
+  /**
+   * Le multiplicateur actif, ou rien.
+   *
+   * Délibérément aveugle à l'événement du site : un buff PAR TORRENT est ce que
+   * cette page annonce, et mélanger les deux ferait afficher « freeleech » sur
+   * chaque release pendant un événement global.
+   */
+  const buff = computed(() => {
+    const t = torrent.value;
+    if (!t || gated.value) return null;
+    if (t.downloadMultiplier === undefined || t.uploadMultiplier === undefined) {
+      return null;
+    }
+    if (t.multipliersUntil && new Date(t.multipliersUntil) <= new Date()) return null;
+    const dl = t.downloadMultiplier as number;
+    const ul = t.uploadMultiplier as number;
+    if (dl === 100 && ul === 100) return null;
+    const kind =
+      dl === 0 && ul === 100 ? 'freeleech' : dl === 100 ? 'upload' : 'mixed';
+    return { kind, dl, ul, until: (t.multipliersUntil as string | null) ?? null };
+  });
+
+  const buffPair = computed(() => {
+    if (!buff.value) return '';
+    const f = (p: number) => `${(p / 100).toLocaleString(locale.value)}×`;
+    return `${f(buff.value.dl)} DL · ${f(buff.value.ul)} UL`;
+  });
+
+  const buffEndsIn = computed(() =>
+    buff.value?.until ? formatUntil(buff.value.until, locale.value) : '',
+  );
+
+  /**
+   * Le lien TMDb, qui accepte les deux formes stockées.
+   *
+   * La colonne porte tantôt `693134`, tantôt `tv/1399` — le préfixe est ce qui
+   * distingue une série d'un film. Sans préfixe on tombe sur `/movie/`, que
+   * TMDb redirige de lui-même vers le bon espace de noms.
+   */
+  const tmdbLink = computed(() => {
+    const raw = torrent.value?.tmdbId as string | null | undefined;
+    if (!raw) return null;
+    const prefixed = raw.match(/^(movie|tv)\/(\d+)$/);
+    if (prefixed) {
+      return {
+        href: `https://www.themoviedb.org/${prefixed[1]}/${prefixed[2]}`,
+        label: prefixed[2]!,
+      };
+    }
+    /*
+     * Un identifiant NU est ambigu : TMDb a deux espaces de noms indépendants
+     * (`/movie/{n}` et `/tv/{n}`) et le même entier résout dans les deux.
+     * `normalizeTmdbId` le dit explicitement côté API — « bare; resolver
+     * guesses ». Deviner « film » systématiquement envoyait sur un 404 toute
+     * série dont l'identifiant a été saisi sans préfixe.
+     *
+     * L'ordre de préférence : le type que TMDb a RÉELLEMENT résolu (il est
+     * dans la charge de métadonnées, donc il ne coûte rien), puis l'indice
+     * tiré de la catégorie, puis « film » en dernier recours.
+     */
+    const resolved = metadata.value?.type;
+    const hinted = deriveTypeHint(torrent.value?.category);
+    const kind = resolved === 'tv' || hinted === 'tv' ? 'tv' : 'movie';
+    return { href: `https://www.themoviedb.org/${kind}/${raw}`, label: raw };
+  });
+
+  /**
+   * La clé de la page de groupe — « toutes les releases de cette œuvre ».
+   *
+   * `/torrents/group/{key}` existe depuis longtemps et cette page n'y renvoyait
+   * jamais, alors que les trois identifiants nécessaires arrivent dans la même
+   * charge utile. C'est la réponse au « laquelle de ces six je prends », déjà
+   * construite, jamais reliée.
+   */
+  const groupKey = computed(() => {
+    const t = torrent.value;
+    if (!t || gated.value) return null;
+    // Le préfixe `movie/` ou `tv/` reste. Il était retiré ici, et c'était un
+    // bug : la clé de groupe du serveur est construite en SQL comme
+    // `'tmdb:' || tmdb_id` (`torrentGroups.ts`), donc elle CONTIENT le
+    // préfixe, la page `/torrents/group/[...key].vue` est un attrape-tout
+    // précisément pour que la barre oblique passe dans l'URL, et le découpage
+    // par saison teste `tmdb_id LIKE 'tv/%'`. Une clé rabotée ne résolvait
+    // rien : `releaseCount: 0`, section des versions vide, lien vers une page
+    // de groupe vide — sur tout torrent dont l'identifiant TMDb a été saisi
+    // par URL, ce que le formulaire d'upload encourage.
+    if (t.tmdbId) return `tmdb:${t.tmdbId}`;
+    if (t.igdbId) return `igdb:${t.igdbId}`;
+    if (t.openlibraryId) return `openlibrary:${t.openlibraryId}`;
+    return null;
+  });
+
+  /** Le panneau de modération passe AU-DESSUS quand il attend une action. */
+  const moderationOnTop = computed(() => {
+    const s = gated.value ? null : torrent.value?.moderationStatus;
+    return s === 'pending' || s === 'changes_requested';
+  });
+
+  /** Un CTA conditionnel : proposer une relance n'a de sens qu'à zéro seeder. */
+  const canAskReseed = computed(
+    () =>
+      loggedIn.value &&
+      !gated.value &&
+      torrent.value?.stats?.seeders === 0 &&
+      !supersessions.value?.supersededBy,
+  );
+
+  const showVolumeCard = computed(
+    () => Number(BigInt(crossSeedStats.value?.totalUploadedBytes ?? '0')) > 0,
+  );
+
+
+  /* ── Métadonnées de l'œuvre ────────────────────────────────────────────── */
+  /**
+   * Reprise de l'ancienne page, sans son `await`.
+   *
+   * Le commentaire d'origine disait que cette requête était faite à part
+   * « so a slow signature lookup never blocks the page render ». Elle était
+   * `await`ée au niveau de `setup` — donc elle bloquait exactement ce qu'elle
+   * prétendait épargner.
+   *
+   * `immediate` dépend du torrent, qui n'est pas encore là quand cette ligne
+   * s'exécute : c'est `watch: [lookupParams]` qui la déclenche à l'arrivée du
+   * détail. La carte d'identité se rend donc sans son affiche, puis avec.
+   */
+  function deriveTypeHint(
+    cat:
+      | { newznabId?: number | null; slug?: string; name?: string }
+      | null
+      | undefined
+  ): 'movie' | 'tv' | 'game' | 'book' | undefined {
+    const id = cat?.newznabId;
+    if (typeof id === 'number') {
+      if (id >= 5000 && id < 6000) return 'tv';
+      if (id >= 2000 && id < 3000) return 'movie';
+      // Newznab buckets 1xxx (Console games) and 4xxx (PC) both map
+      // to IGDB. We treat them as the same `game` hint — IGDB indexes
+      // every platform under one game id.
+      if ((id >= 1000 && id < 2000) || (id >= 4000 && id < 5000)) return 'game';
+      // 7xxx is the book/ebook/comic/magazine decade.
+      if (id >= 7000 && id < 8000) return 'book';
+    }
+    const text = `${cat?.slug || ''} ${cat?.name || ''}`
+      .toLowerCase()
+      .normalize('NFD')
+      .replace(/[̀-ͯ]/g, '');
+    if (/\b(?:tv|seri|episod|saison|season|show|anime)/.test(text)) return 'tv';
+    if (/\b(?:movie|film|cinema|cine)/.test(text)) return 'movie';
+    if (/\b(?:game|games|jeu|jeux|console|playstation|xbox|nintendo|switch|pc-?game)/.test(text)) return 'game';
+    if (/\b(?:book|ebook|e-book|epub|mobi|azw3|livre|livres|comics?|bd|manga|magazine|revue)/.test(text)) return 'book';
+    return undefined;
+  }
+  
+  const lookupParams = computed(() => {
+    const t = torrent.value;
+    if (!t) return null;
+    const type = deriveTypeHint(t.category);
+    // Prefer the source that matches the category hint when we have
+    // multiple ids stored — a TV box with both a TMDb and an IGDB id
+    // should hit TMDb, a book box with both an Open Library and TMDb
+    // id should hit Open Library, and so on.
+    if (type === 'book' && t.openlibraryId) {
+      return { source: 'openlibrary', id: t.openlibraryId, type };
+    }
+    if (type === 'game' && t.igdbId) {
+      return { source: 'igdb', id: t.igdbId, type };
+    }
+    if (t.tmdbId) return { source: 'tmdb', id: t.tmdbId, type };
+    if (t.imdbId) return { source: 'imdb', id: t.imdbId, type };
+    if (t.tvdbId) return { source: 'tvdb', id: t.tvdbId, type };
+    if (t.igdbId) return { source: 'igdb', id: t.igdbId, type };
+    if (t.openlibraryId)
+      return { source: 'openlibrary', id: t.openlibraryId, type };
+    return null;
+  });
+  
+  const {
+    data: metadataResponse,
+    status: metadataStatus,
+    execute: executeMetadata,
+  } = useFetch<MediaMetadataResponse>(
+    '/api/metadata/lookup',
+    {
+      // useFetch refetches when reactive query params change.
+      query: computed(() => {
+        const p = lookupParams.value;
+        if (!p) return {};
+        const out: Record<string, string> = { source: p.source, id: p.id };
+        if (p.type) out.type = p.type;
+        return out;
+      }),
+      // Skip the call entirely when there's nothing to look up — saves
+      // the 503 response when the operator hasn't set TMDB_API_KEY.
+      immediate: !!lookupParams.value,
+      watch: [lookupParams],
+      // Don't surface a 5xx to the page error boundary; the metadata
+      // card just won't render and the rest of the page works.
+      onResponseError({ response }) {
+        if (response.status === 503) return;
+      },
+    }
+  );
+  
+  const metadata = computed(
+    () => metadataResponse.value?.metadata ?? null
+  );
+
+  /**
+   * « On ne sait pas encore », par opposition à « il n'y a rien ».
+   *
+   * `immediate` est faux au montage — la requête dépend du torrent, qui n'est
+   * pas résolu à cet instant — donc le statut vaut `idle` puis `pending`. Les
+   * deux veulent dire la même chose pour la carte d'identité : une recherche
+   * est attendue et n'a pas répondu. Sans cette distinction, la carte
+   * affirmait « Sans affiche » sur toute page dont l'œuvre est connue, le
+   * temps d'un aller-retour.
+   */
+  const metadataPending = computed(
+    () =>
+      !!lookupParams.value &&
+      (metadataStatus.value === 'idle' || metadataStatus.value === 'pending'),
+  );
+
+  /**
+   * Ce que la PAGE attend, dans son propre `<script setup>`.
+   *
+   * Le détail, puis la recherche de métadonnées — dans cet ordre, parce que la
+   * seconde a besoin des identifiants que porte le premier. Rien n'est attendu
+   * ICI : un `await` dans ce fichier perdrait le contexte Nuxt (voir l'en-tête).
+   * La page, elle, est un `<script setup>` : le compilateur de Vue y enveloppe
+   * l'attente et rétablit l'instance.
+   *
+   * Pourquoi attendre l'affiche alors que le reste est en `lazy` : sans ça
+   * elle arrive APRÈS l'hydratation, et le serveur a déjà écrit le substitut
+   * « Sans affiche » à sa place — un `<div>` que le client remplace par un
+   * `<img>`. Vue compte ça comme une non-concordance d'hydratation, à chaque
+   * chargement de chaque page dont l'œuvre est connue, et l'affiche apparaît
+   * en sautant. Le coût réel est faible : `/api/metadata/lookup` sert depuis
+   * Redis (TTL positif ET négatif), donc seule la toute première visite d'une
+   * œuvre paie l'aller-retour vers TMDb.
+   *
+   * `runWithContext` n'est pas une précaution : sans lui, `execute()` appelé
+   * depuis une continuation de promesse lève `NUXT_E1001` — la continuation
+   * n'est plus dans le contexte Nuxt, exactement comme le code après un
+   * `await` dans un `.ts`. Le premier jet enveloppait l'appel d'un
+   * `.catch(() => undefined)`, qui a AVALÉ cette erreur : la page rendait 200
+   * sans affiche, et la seule trace était un `[NUXT_E1001]` dans les journaux
+   * du conteneur. Le `catch` ci-dessous journalise pour cette raison — une
+   * requête qui échoue vraiment (503 sans clé TMDb) n'arrive pas ici, elle
+   * atterrit dans `error` sans rejeter.
+   */
+  const ready = Promise.resolve(detail)
+    .then(() =>
+      nuxtApp.runWithContext(() =>
+        lookupParams.value ? executeMetadata() : undefined,
+      ),
+    )
+    .catch((err) => {
+      console.warn('[torrent-detail] la recherche de métadonnées a rejeté :', err);
+      return undefined;
+    });
+
+  /** Le fil complet, pas la première page : ce que le sommaire annonce. */
+  const commentCount = computed<number>(() => {
+    const t = torrent.value as { commentCount?: number; comments?: unknown[] } | null | undefined;
+    return t?.commentCount ?? t?.comments?.length ?? 0;
+  });
+  const comments = computed<TorrentComment[]>(
+    () => (gated.value ? [] : (torrent.value?.comments ?? [])) as TorrentComment[],
+  );
+
+  return {
+    // données
+    torrent,
+    error,
+    comments,
+    commentCount,
+    crossSeeds,
+    supersessions,
+    crossSeedStats,
+    federatedCrossSeeds,
+    obligation,
+    refreshObligation,
+    metadata,
+    metadataPending,
+    ready,
+    // contexte
+    user,
+    loggedIn,
+    federationEnabled,
+    // permissions
+    isOwner,
+    isStaff,
+    canEdit,
+    canDelete,
+    canReport,
+    canFavorite,
+    // dérivés
+    gated,
+    buff,
+    buffPair,
+    buffEndsIn,
+    tmdbLink,
+    groupKey,
+    moderationOnTop,
+    canAskReseed,
+    showVolumeCard,
+    // actions
+    refreshTorrent,
+    refreshSupersessions,
+  };
+}
diff --git a/apps/web/app/layouts/default.vue b/apps/web/app/layouts/default.vue
index 0dbf3fdd..9782ed92 100644
--- a/apps/web/app/layouts/default.vue
+++ b/apps/web/app/layouts/default.vue
@@ -70,23 +70,48 @@
         </NuxtLink>
 
         <!-- Desktop nav: hidden below md, visible from md up.
-             From md→lg the labels collapse so the search bar has room
-             without bumping the user-menu off-screen; lg+ shows full
-             icon+label pairs again. -->
+             The labels collapse to icons until xl so the search bar has room
+             without bumping the user-menu off-screen.
+
+             Le seuil était `lg` (1024 px), et il était TROP BAS — mesuré sur
+             un compte d'équipe, six entrées : les libellés font passer cette
+             barre de 236 px à 599,7. Additionnée au bloc de droite (462,6,
+             incompressible lui aussi) et aux écarts, elle réclamait 1098,3 px
+             quand la rangée n'en offrait que 1060 à 1100 px de fenêtre.
+             Résultat entre 1024 et ~1138 : le nom du site ET la barre de
+             recherche réduits à ZÉRO — la marque disparaissait, seule la
+             tuile du logo dépassait de son propre conteneur — et la page
+             défilait quand même de 46 px à l'horizontale.
+
+             `xl` (1280) supprimait bien le débordement, mais laissait la
+             recherche à 33 px : un champ où l'on ne peut pas taper. À 1280 la
+             rangée n'offre que 141 px une fois la barre de navigation et le
+             bloc de droite servis, et la marque en prend 110. `2xl` est donc
+             le premier seuil où les libellés ET la recherche tiennent
+             ensemble — mesuré : 185 px de champ à 1536.
+
+             Ce qu'on échange est une REDONDANCE : chaque entrée porte déjà
+             son icône et son `title`. La recherche, elle, n'a pas de repli
+             dans cette barre — le commentaire du formulaire l'appelle « the
+             centerpiece ». -->
         <nav class="hidden md:flex items-center gap-1 flex-shrink-0">
-          <NuxtLink
-            v-for="link in visibleNavLinks"
-            :key="link.to"
-            :to="link.to"
-            class="px-2.5 py-1.5 text-xs font-medium rounded transition-all text-text-secondary hover:bg-fg-default/5 hover:text-text-primary"
-            active-class="bg-fg-default/10 text-text-strong"
-            :title="$t(link.labelKey)"
-          >
-            <div class="flex items-center gap-2">
-              <Icon :name="link.icon" class="text-base" />
-              <span class="hidden lg:inline">{{ $t(link.labelKey) }}</span>
-            </div>
-          </NuxtLink>
+          <template v-for="link in visibleNavLinks" :key="link.to">
+            <!-- « Torrents » porte un menu : les raccourcis et les catégories, au survol
+                 ou au chevron. Le lien lui-même mène toujours au catalogue. -->
+            <NavTorrentsMenu v-if="link.to === '/torrents' && user" :label="$t(link.labelKey)" :icon="link.icon" />
+            <NuxtLink
+              v-else
+              :to="link.to"
+              class="px-2.5 py-1.5 text-xs font-medium rounded transition-all text-text-secondary hover:bg-fg-default/5 hover:text-text-primary"
+              active-class="bg-fg-default/10 text-text-strong"
+              :title="$t(link.labelKey)"
+            >
+              <div class="flex items-center gap-2">
+                <Icon :name="link.icon" class="text-base" />
+                <span class="hidden 2xl:inline">{{ $t(link.labelKey) }}</span>
+              </div>
+            </NuxtLink>
+          </template>
         </nav>
 
         <!-- Navbar search — the centerpiece. Grows to fill the gap
@@ -209,7 +234,7 @@
             </div>
             <button
               @click="refreshStats"
-              class="p-1 rounded hover:bg-fg-default/5 text-text-muted hover:text-text-secondary transition-colors"
+              class="p-1.5 rounded hover:bg-fg-default/5 text-text-muted hover:text-text-secondary transition-colors"
               :title="$t('nav.refreshStats')"
             >
               <Icon name="ph:arrows-clockwise" class="text-xs" />
@@ -833,7 +858,7 @@
           ></span>
           <span
             v-if="appVersion"
-            class="text-text-muted/60"
+            class="text-text-muted"
             :title="`Trackarr v${appVersion}`"
             >v{{ appVersion }}</span
           >
@@ -844,7 +869,7 @@
                can find is a notice nobody was given. -->
           <NuxtLink
             to="/privacy"
-            class="text-[10px] font-mono uppercase tracking-widest text-text-muted hover:text-text-strong transition-colors"
+            class="inline-flex items-center min-h-[1.5rem] text-[10px] font-mono uppercase tracking-widest text-text-muted hover:text-text-strong transition-colors"
           >{{ $t('privacy.eyebrow') }}</NuxtLink>
           <a
             href="https://n0w.me/"
diff --git a/apps/web/app/pages/admin/audit.vue b/apps/web/app/pages/admin/audit.vue
index 598a7aa7..8b5acbbd 100644
--- a/apps/web/app/pages/admin/audit.vue
+++ b/apps/web/app/pages/admin/audit.vue
@@ -629,6 +629,8 @@ useHead({ title: () => t('admin.audit.title') });
   gap: 0.35rem;
 }
 .au-actor-name {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 20 px avant. */
+  padding-block: 0.25rem;
   font-weight: 600;
 }
 a.au-actor-name:hover { color: rgb(var(--accent-warm)); }
diff --git a/apps/web/app/pages/admin/banned-ips.vue b/apps/web/app/pages/admin/banned-ips.vue
index ef866952..535bd03b 100644
--- a/apps/web/app/pages/admin/banned-ips.vue
+++ b/apps/web/app/pages/admin/banned-ips.vue
@@ -689,6 +689,8 @@ async function onUnban(item: BannedIp) {
   font-variant-numeric: tabular-nums;
 }
 .kpi-sub {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 14 px avant. */
+  padding-block: 0.25rem;
   font-size: 0.6563rem;
   color: rgb(var(--fg-muted));
   letter-spacing: calc(0.04em * var(--tracking-scale));
diff --git a/apps/web/app/pages/admin/irc.vue b/apps/web/app/pages/admin/irc.vue
index f0ca0c04..ae10deb5 100644
--- a/apps/web/app/pages/admin/irc.vue
+++ b/apps/web/app/pages/admin/irc.vue
@@ -713,7 +713,7 @@ async function sendTest() {
 }
 .irc-grid {
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(13rem, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 13rem), 1fr));
   gap: 0.75rem;
   /* From the top. `end` was an attempt to line a checkbox up with its
      neighbours' inputs, and it made every row bottom-aligned instead — so a
@@ -840,7 +840,7 @@ async function sendTest() {
 .irc-card--stats { gap: 0.5rem; }
 .irc-stats {
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(7rem, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 7rem), 1fr));
   gap: 0.75rem;
 }
 .irc-stats dt {
diff --git a/apps/web/app/pages/admin/search-misses.vue b/apps/web/app/pages/admin/search-misses.vue
new file mode 100644
index 00000000..d894c9ff
--- /dev/null
+++ b/apps/web/app/pages/admin/search-misses.vue
@@ -0,0 +1,3 @@
+<template>
+  <AdminSearchMisses />
+</template>
diff --git a/apps/web/app/pages/admin/settings.vue b/apps/web/app/pages/admin/settings.vue
index 66443889..f0f3997b 100644
--- a/apps/web/app/pages/admin/settings.vue
+++ b/apps/web/app/pages/admin/settings.vue
@@ -8,6 +8,7 @@
     <AdminMessagingBroadcast />
     <AdminSearchSettings />
     <AdminRequestSettings />
+    <AdminHnrSettings />
     <AdminPanic />
   </div>
 </template>
diff --git a/apps/web/app/pages/chat.vue b/apps/web/app/pages/chat.vue
index 385655a7..4fef530a 100644
--- a/apps/web/app/pages/chat.vue
+++ b/apps/web/app/pages/chat.vue
@@ -953,6 +953,8 @@ onMounted(() => refresh());
   margin: 0 0 0.15rem;
 }
 .room-msg-author {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 19 px avant. */
+  padding-block: 0.25rem;
   font-size: 0.8rem;
   font-weight: 700;
   color: rgb(var(--fg-strong));
diff --git a/apps/web/app/pages/favorites.vue b/apps/web/app/pages/favorites.vue
index 2b02330e..a1f01320 100644
--- a/apps/web/app/pages/favorites.vue
+++ b/apps/web/app/pages/favorites.vue
@@ -393,9 +393,9 @@ async function unfavorite(row: FavoriteRow) {
      every side. Matches .shop-bg, which already had this right. */
   position: fixed;
   top: -2rem;
-  left: 50%;
-  width: 100vw;
-  margin-left: -50vw;
+  left: 0;
+  right: 0;
+  overflow: hidden;
   height: 70vh;
   max-height: 520px;
   z-index: -1;
@@ -591,7 +591,7 @@ async function unfavorite(row: FavoriteRow) {
   margin: 0;
   padding: 0.5rem 0 0;
   display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+  grid-template-columns: repeat(auto-fill, minmax(min(100%, 280px), 1fr));
   gap: 1.4rem 1.25rem;
   /* The grid itself is dead-straight; jitter lives on individual
      cards so the visual rhythm reads as "a pile someone touched"
diff --git a/apps/web/app/pages/following.vue b/apps/web/app/pages/following.vue
index 0bec7ef9..f4370c87 100644
--- a/apps/web/app/pages/following.vue
+++ b/apps/web/app/pages/following.vue
@@ -476,9 +476,9 @@ async function unfollow(row: PersonaRow) {
      every side. Matches .shop-bg, which already had this right. */
   position: fixed;
   top: -2rem;
-  left: 50%;
-  width: 100vw;
-  margin-left: -50vw;
+  left: 0;
+  right: 0;
+  overflow: hidden;
   height: 75vh;
   max-height: 560px;
   z-index: -1;
@@ -703,7 +703,7 @@ async function unfollow(row: PersonaRow) {
   margin: 0;
   padding: 0;
   display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+  grid-template-columns: repeat(auto-fill, minmax(min(100%, 280px), 1fr));
   gap: 1.6rem 1.4rem;
 }
 
diff --git a/apps/web/app/pages/forum/topic/[id].vue b/apps/web/app/pages/forum/topic/[id].vue
index 4815c256..a2887f1d 100644
--- a/apps/web/app/pages/forum/topic/[id].vue
+++ b/apps/web/app/pages/forum/topic/[id].vue
@@ -612,6 +612,8 @@ onMounted(() => {
   flex-wrap: wrap;
 }
 .article-crumb-link {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 16 px avant. */
+  padding-block: 0.25rem;
   color: var(--ink-fade);
   text-decoration: none;
   transition: color var(--dur-1);
diff --git a/apps/web/app/pages/index.vue b/apps/web/app/pages/index.vue
index 925b9dcf..70ee3b9a 100644
--- a/apps/web/app/pages/index.vue
+++ b/apps/web/app/pages/index.vue
@@ -969,7 +969,6 @@ function useCounter(target: Ref<number>) {
   border: 1px solid rgb(var(--line-default));
   background: rgb(var(--bg-surface) / 0.6);
   backdrop-filter: blur(6px);
-  -webkit-backdrop-filter: blur(6px);
   border-radius: var(--radius-sm);
   overflow: hidden;
 }
@@ -1143,6 +1142,8 @@ function useCounter(target: Ref<number>) {
   transition: color var(--dur-2) ease;
 }
 .mc-ledger-name {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 18 px avant. */
+  padding-block: 0.25rem;
   display: block;
   min-width: 0;
   color: rgb(var(--fg-strong));
@@ -1319,6 +1320,8 @@ function useCounter(target: Ref<number>) {
   min-width: 0;
 }
 .mc-hot-name {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 18 px avant. */
+  padding-block: 0.25rem;
   display: block;
   min-width: 0;
   font-family: var(--font-mono);
diff --git a/apps/web/app/pages/me.vue b/apps/web/app/pages/me.vue
index 4e2d12fd..33ae6f0e 100644
--- a/apps/web/app/pages/me.vue
+++ b/apps/web/app/pages/me.vue
@@ -1539,9 +1539,9 @@ function formatDuration(seconds: number) {
      every side. Matches .shop-bg, which already had this right. */
   position: fixed;
   top: -2rem;
-  left: 50%;
-  width: 100vw;
-  margin-left: -50vw;
+  left: 0;
+  right: 0;
+  overflow: hidden;
   height: 70vh;
   z-index: -1;
   overflow: hidden;
@@ -1908,6 +1908,8 @@ function formatDuration(seconds: number) {
   font-variant-numeric: tabular-nums;
 }
 .kpi-sub {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 14 px avant. */
+  padding-block: 0.35rem;
   font-size: 0.6563rem;
   color: rgb(var(--fg-muted));
   letter-spacing: calc(0.04em * var(--tracking-scale));
@@ -2114,7 +2116,11 @@ function formatDuration(seconds: number) {
   color: rgb(var(--accent-warm-text));
 }
 .bv-trigger-label {
-  flex-shrink: 0;
+  /* Pas `flex-shrink: 0` : ce libellé est traduit, en capitales espacées, et
+     il refusait de se réduire — sur un téléphone il poussait le chevron À
+     L'EXTÉRIEUR du bouton, 26 px au-delà de son bord, et c'était toute la
+     cause des 6 px de défilement horizontal de la page. */
+  min-width: 0;
   font-family: var(--font-mono);
   font-size: 0.6875rem;
   font-weight: 700;
diff --git a/apps/web/app/pages/mod/anti-cheat.vue b/apps/web/app/pages/mod/anti-cheat.vue
index adbaf3cb..4db3631d 100644
--- a/apps/web/app/pages/mod/anti-cheat.vue
+++ b/apps/web/app/pages/mod/anti-cheat.vue
@@ -1389,6 +1389,8 @@ const emptySub = computed(() => {
   font-style: italic;
 }
 .ac-case-target {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 16 px avant. */
+  min-height: 1.5rem;
   display: inline-flex;
   align-items: center;
   gap: 0.3rem;
@@ -1498,7 +1500,7 @@ const emptySub = computed(() => {
 
 .ac-evidence {
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 220px), 1fr));
   gap: 0.6rem 1rem;
   margin: 0;
 }
@@ -1619,7 +1621,7 @@ const emptySub = computed(() => {
 }
 .ac-verdicts {
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 140px), 1fr));
   gap: 0.5rem;
   border: 0;
   padding: 0;
@@ -1952,7 +1954,6 @@ const emptySub = computed(() => {
     0 18px 48px -16px rgb(var(--shadow-color) / calc(0.7 * var(--shadow-strength))),
     0 4px 18px -6px rgb(var(--shadow-color) / calc(0.4 * var(--shadow-strength)));
   backdrop-filter: blur(14px);
-  -webkit-backdrop-filter: blur(14px);
   transform: translateX(-50%);
 }
 .ac-bulkbar-summary {
diff --git a/apps/web/app/pages/mod/index.vue b/apps/web/app/pages/mod/index.vue
index 97b3dd21..c118ea9b 100644
--- a/apps/web/app/pages/mod/index.vue
+++ b/apps/web/app/pages/mod/index.vue
@@ -545,7 +545,7 @@ function actionVerb(status: string | null): string {
 /* ── Stat tiles ─────────────────────────────────────────── */
 .wt-tiles {
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 180px), 1fr));
   gap: 1rem;
 }
 .tile {
@@ -760,6 +760,8 @@ function actionVerb(status: string | null): string {
   padding-top: 0.15rem;
 }
 .queue-name {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 20 px avant. */
+  padding-block: 0.25rem;
   font-size: 0.85rem;
   font-weight: 600;
   color: rgb(var(--fg-strong));
@@ -857,6 +859,8 @@ function actionVerb(status: string | null): string {
   color: rgb(var(--fg-muted));
 }
 .log-target {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 19 px avant. */
+  padding-block: 0.25rem;
   font-size: 0.78rem;
   color: rgb(var(--fg-strong));
   text-decoration: none;
diff --git a/apps/web/app/pages/mod/tickets.vue b/apps/web/app/pages/mod/tickets.vue
index 0b64c32a..25ebd6cf 100644
--- a/apps/web/app/pages/mod/tickets.vue
+++ b/apps/web/app/pages/mod/tickets.vue
@@ -443,7 +443,12 @@ watch(tickets, (rows) => {
   color: rgb(var(--fg-muted));
   font-size: 0.75rem;
 }
-.tq-who { color: inherit; text-decoration: none; }
+/* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 18 px avant. */
+.tq-who {
+  padding-block: 0.25rem;
+  color: inherit;
+  text-decoration: none;
+}
 .tq-who:hover { text-decoration: underline; }
 .tq-who--gone { text-decoration: line-through; text-decoration-thickness: 1px; }
 .tq-sep { color: rgb(var(--fg-subtle)); }
diff --git a/apps/web/app/pages/requests/[id].vue b/apps/web/app/pages/requests/[id].vue
index dc0649af..8e5f84da 100644
--- a/apps/web/app/pages/requests/[id].vue
+++ b/apps/web/app/pages/requests/[id].vue
@@ -919,9 +919,9 @@ async function fill() {
      every side. Matches .shop-bg, which already had this right. */
   position: fixed;
   top: -2rem;
-  left: 50%;
-  width: 100vw;
-  margin-left: -50vw;
+  left: 0;
+  right: 0;
+  overflow: hidden;
   height: 60vh;
   max-height: 480px;
   z-index: -1;
@@ -1763,7 +1763,7 @@ async function fill() {
 .req-edit-row {
   display: grid;
   gap: 1rem;
-  grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 12rem), 1fr));
 }
 .req-edit-hint {
   margin: 0;
diff --git a/apps/web/app/pages/requests/index.vue b/apps/web/app/pages/requests/index.vue
index d331ca95..7701a335 100644
--- a/apps/web/app/pages/requests/index.vue
+++ b/apps/web/app/pages/requests/index.vue
@@ -335,9 +335,9 @@ function formatReward(n: number): string {
      every side. Matches .shop-bg, which already had this right. */
   position: fixed;
   top: -2rem;
-  left: 50%;
-  width: 100vw;
-  margin-left: -50vw;
+  left: 0;
+  right: 0;
+  overflow: hidden;
   height: 70vh;
   max-height: 520px;
   z-index: -1;
diff --git a/apps/web/app/pages/requests/new.vue b/apps/web/app/pages/requests/new.vue
index 1a7c4663..a7dc2710 100644
--- a/apps/web/app/pages/requests/new.vue
+++ b/apps/web/app/pages/requests/new.vue
@@ -316,9 +316,9 @@ async function submit() {
      every side. Matches .shop-bg, which already had this right. */
   position: fixed;
   top: -2rem;
-  left: 50%;
-  width: 100vw;
-  margin-left: -50vw;
+  left: 0;
+  right: 0;
+  overflow: hidden;
   height: 60vh;
   max-height: 460px;
   z-index: -1;
@@ -484,7 +484,7 @@ async function submit() {
 
 .filing-cat-grid {
   display: grid;
-  grid-template-columns: repeat(auto-fill, minmax(140px, 1fr));
+  grid-template-columns: repeat(auto-fill, minmax(min(100%, 140px), 1fr));
   gap: 0.5rem;
 }
 .filing-cat-grid--sub {
diff --git a/apps/web/app/pages/settings.vue b/apps/web/app/pages/settings.vue
index f465c4c3..44090822 100644
--- a/apps/web/app/pages/settings.vue
+++ b/apps/web/app/pages/settings.vue
@@ -1620,6 +1620,8 @@ onBeforeRouteLeave((_to, _from, next) => {
   margin-bottom: 2rem;
 }
 .back-link {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 15 px avant. */
+  min-height: 1.5rem;
   display: inline-flex;
   align-items: center;
   gap: 0.5rem;
@@ -2385,7 +2387,7 @@ onBeforeRouteLeave((_to, _from, next) => {
 /* ─── Account info grid ────────────────────────────────────── */
 .info-grid {
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(14rem, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 14rem), 1fr));
   gap: 0.75rem;
   margin: 0;
 }
diff --git a/apps/web/app/pages/shop.vue b/apps/web/app/pages/shop.vue
index d7d01f53..e5f244ef 100644
--- a/apps/web/app/pages/shop.vue
+++ b/apps/web/app/pages/shop.vue
@@ -416,6 +416,8 @@ function onBalanceFromPool(value: number) {
 }
 
 .back-link {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 15 px avant. */
+  min-height: 1.5rem;
   display: inline-flex;
   align-items: center;
   gap: 0.4rem;
diff --git a/apps/web/app/pages/stats.vue b/apps/web/app/pages/stats.vue
index b8717a70..7a63ef05 100644
--- a/apps/web/app/pages/stats.vue
+++ b/apps/web/app/pages/stats.vue
@@ -98,7 +98,7 @@
       </div>
       <ul v-else class="st-bars">
         <li v-for="cat in categories" :key="cat.id" class="st-bar-row">
-          <NuxtLink :to="`/torrents?category=${cat.slug}`" class="st-bar-name">
+          <NuxtLink :to="`/torrents?c=${cat.id}`" class="st-bar-name">
             {{ cat.name }}
           </NuxtLink>
           <div class="st-bar-track">
@@ -867,7 +867,7 @@ function delay(index: number) {
      each ranking panel is 354px wide and still renders its size column — which
      truncated release names at about 28 characters, and a scene name is
      unrecognisable at 28 characters. */
-  grid-template-columns: repeat(auto-fit, minmax(26rem, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 26rem), 1fr));
   gap: 1.75rem;
 }
 
@@ -902,7 +902,7 @@ function delay(index: number) {
 
 .st-charts {
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(16rem, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 16rem), 1fr));
   gap: 1.25rem 1.5rem;
 }
 .st-chart-wide { grid-column: 1 / -1; }
@@ -917,6 +917,8 @@ function delay(index: number) {
   font-size: 0.75rem;
 }
 .st-bar-name {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 18 px avant. */
+  padding-block: 0.25rem;
   color: rgb(var(--fg-default));
   overflow: hidden;
   text-overflow: ellipsis;
@@ -1004,6 +1006,8 @@ function delay(index: number) {
   text-align: right;
 }
 .st-rank-name, .st-board-name {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 20 px avant. */
+  padding-block: 0.25rem;
   color: rgb(var(--fg-default));
   overflow: hidden;
   text-overflow: ellipsis;
@@ -1037,6 +1041,8 @@ function delay(index: number) {
   gap: 0.6rem;
 }
 .st-more {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 17 px avant. */
+  padding-block: 0.25rem;
   align-self: flex-start;
   font-size: 0.6875rem;
   color: rgb(var(--fg-subtle));
@@ -1071,7 +1077,7 @@ function delay(index: number) {
 .st-year-chart { max-width: 42rem; }
 .st-year-lists {
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(16rem, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 16rem), 1fr));
   gap: 1.25rem;
 }
 /* A heading, at heading size. `.eyebrow` at 10px uppercase was being used for
@@ -1093,6 +1099,8 @@ function delay(index: number) {
 }
 .st-mini li:last-child { border-bottom: 0; }
 .st-mini-link {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 20 px avant. */
+  padding-block: 0.25rem;
   color: rgb(var(--fg-default));
   overflow: hidden;
   text-overflow: ellipsis;
diff --git a/apps/web/app/pages/torrents/[hash]/index.vue b/apps/web/app/pages/torrents/[hash]/index.vue
index 583833c2..cbeaeddb 100644
--- a/apps/web/app/pages/torrents/[hash]/index.vue
+++ b/apps/web/app/pages/torrents/[hash]/index.vue
@@ -1,1498 +1,186 @@
-<template>
-  <!-- ─── Adult-content gate ────────────────────────────────────────
-       Renders when /api/torrents/:hash returned the redacted shape
-       because the torrent's category is flagged adult and the viewer
-       hasn't opted in. We deliberately don't show the torrent name
-       or any metadata — the redacted bar mimics the position of the
-       title so the operator's filter is visibly working, and the CTA
-       points at /settings#adult so a user who opted out by mistake
-       can flip the switch in one click. -->
-  <section
-    v-if="torrent && torrent.gatedAdult"
-    class="adult-gate"
-    aria-labelledby="adult-gate-title"
-  >
-    <NuxtLink to="/torrents" class="adult-gate__back">
-      <Icon name="ph:arrow-left-bold" />
-      {{ $t('torrents.detail.backToIndex') }}
-    </NuxtLink>
-
-    <div class="adult-gate__panel">
-      <header class="adult-gate__hatch">
-        <span class="adult-gate__hatch-label">
-          <Icon name="ph:eye-slash-fill" />
-          {{ $t('torrents.detail.adultGate.filterActive') }}
-        </span>
-        <span class="adult-gate__hatch-route">
-          /torrents/<span class="adult-gate__hash">{{ redactedHash }}</span>
-        </span>
-      </header>
-
-      <div class="adult-gate__body">
-        <p class="adult-gate__eyebrow">
-          {{ $t('torrents.detail.adultGate.eyebrow') }}
-        </p>
-        <h1 id="adult-gate-title" class="adult-gate__title">
-          <span class="adult-gate__title-word">{{ $t('torrents.detail.adultGate.titleWord') }}</span>
-          <span class="adult-gate__title-stamp" aria-hidden="true">
-            <span class="adult-gate__title-stamp-inner">{{ $t('torrents.detail.adultGate.titleStamp') }}</span>
-          </span>
-        </h1>
-
-        <p class="adult-gate__redacted" aria-hidden="true">
-          <span></span><span></span><span></span>
-        </p>
-
-        <dl class="adult-gate__meta">
-          <div>
-            <dt>{{ $t('common.category') }}</dt>
-            <dd>{{ torrent.category?.name ?? 'XXX' }}</dd>
-          </div>
-          <div>
-            <dt>{{ $t('torrents.detail.adultGate.reasonLabel') }}</dt>
-            <dd>{{ $t('torrents.detail.adultGate.reasonValue') }}</dd>
-          </div>
-          <div>
-            <dt>{{ $t('torrents.detail.adultGate.reachableIn') }}</dt>
-            <dd>{{ $t('torrents.detail.adultGate.reachableValue') }}</dd>
-          </div>
-        </dl>
-
-        <p class="adult-gate__copy">
-          {{ $t('torrents.detail.adultGate.copy') }}
-        </p>
-
-        <div class="adult-gate__actions">
-          <NuxtLink to="/settings" class="adult-gate__cta">
-            <Icon name="ph:eye-bold" />
-            <span>{{ $t('torrents.detail.adultGate.enable') }}</span>
-          </NuxtLink>
-          <NuxtLink to="/torrents" class="adult-gate__cta adult-gate__cta--ghost">
-            <Icon name="ph:list-bold" />
-            <span>{{ $t('torrents.detail.adultGate.browseSafe') }}</span>
-          </NuxtLink>
-        </div>
-      </div>
-
-      <footer class="adult-gate__foot">
-        <span>{{ $t('torrents.detail.adultGate.footer') }}</span>
-        <span class="adult-gate__foot-mono">/settings#adult</span>
-      </footer>
-    </div>
-  </section>
-
-  <div v-else-if="torrent" class="release-page">
-    <!-- ── Decorative atmosphere ──────────────────────────────────
-         Two soft gradient blobs (accent + warning hues) plus a grain
-         overlay live behind the content. Same vocabulary as
-         /reports so the app reads as one editorial product. -->
-    <div class="release-aura" aria-hidden="true">
-      <span class="aura-blob aura-blob--a" />
-      <span class="aura-blob aura-blob--b" />
-      <span class="aura-grain" />
-    </div>
-
-    <NuxtLink to="/torrents" class="release-back">
-      <Icon name="ph:arrow-left-bold" />
-      {{ $t('torrents.detail.backToIndex') }}
-    </NuxtLink>
-
-    <!-- ─── Moderation panel (top placement) ───────────────────
-         When the torrent is in a non-final state (pending or
-         changes_requested) we surface the panel above the fold so
-         the uploader sees the moderator's instructions before any
-         metadata. Final states (accepted / rejected) keep the panel
-         at the bottom of the page so the conversation doesn't push
-         the public-facing content down. -->
-    <div v-if="moderationOnTop" class="mb-8">
-      <TorrentModerationPanel
-        :hash="torrent.infoHash"
-        :status="(torrent.moderationStatus as 'pending' | 'accepted' | 'changes_requested' | 'rejected')"
-        :uploader-id="torrent.uploaderId ?? null"
-        @status-change="onModerationStatusChange"
-      />
-    </div>
-
-    <!-- ╔══════════════════════════════════════════════════════════╗
-         ║  HERO — release press-sheet                              ║
-         ║  Eyebrow · big mono title · chips · primary CTA · meta   ║
-         ║  Vertical status-coloured tab on the left edge gives the ║
-         ║  card the feel of a physical document.                    ║
-         ╚══════════════════════════════════════════════════════════╝ -->
-    <section
-      class="hero"
-      :class="[`hero--status-${torrent.moderationStatus || 'accepted'}`]"
-    >
-      <header class="hero-eyebrow">
-        <span class="hero-eyebrow-mark" aria-hidden="true">§</span>
-        <!-- Category name doubles as the eyebrow label so the page
-             opens with the most concrete "what is this" signal. Falls
-             back to a generic "Dossier" only when the row carries no
-             category at all (rare — uncategorised uploads are usually
-             rejected before they reach a detail page). -->
-        <span class="hero-eyebrow-label">{{
-          torrent.category?.name || $t('torrents.detail.hero.case')
-        }}</span>
-        <span class="hero-eyebrow-sep">·</span>
-        <time
-          class="hero-eyebrow-date"
-          :datetime="torrent.createdAt"
-          :title="formatDate(torrent.createdAt)"
-        >
-          {{ formatAge(torrent.createdAt).toUpperCase() }}
-        </time>
-        <span
-          v-if="torrent.moderationStatus && torrent.moderationStatus !== 'accepted'"
-          class="hero-eyebrow-sep"
-        >·</span>
-        <TorrentModerationBadge
-          v-if="torrent.moderationStatus && torrent.moderationStatus !== 'accepted'"
-          :status="torrent.moderationStatus"
-          size="sm"
-        />
-        <!-- The buff this release carries ON ITS OWN. Deliberately blind to a
-             site-wide event: a badge on one torrent among a hundred has to
-             mean this one, or it means nothing. -->
-        <template v-if="buff">
-          <span class="hero-eyebrow-sep">·</span>
-          <span class="buff-badge" :class="`buff-badge--${buff.kind}`">
-            <Icon :name="buff.icon" />
-            <!-- A named buff says its name; an unnamed one says its numbers.
-                 "Boosted" told a member a multiplier was in force and refused to
-                 say which, so they could not tell a 0.25× download from a 3×
-                 upload — the one thing that decides whether it is worth
-                 grabbing now. Both figures are already computed here. -->
-            {{ buff.kind === 'custom' ? buffPair : $t(`torrent.buff.${buff.kind}`) }}
-            <span v-if="buffEndsIn" class="buff-until" :title="formatDate(buff.until!)">
-              {{ $t('torrent.buff.endsIn', { when: buffEndsIn }) }}
-            </span>
-          </span>
-        </template>
-        <span class="hero-eyebrow-spacer" aria-hidden="true" />
-        <!-- Favorite star — sits to the left of the report button so
-             the "save" action is the warmer affordance and the
-             "flag" action stays the colder one. Both live in the
-             eyebrow strip rather than the main CTA row so they
-             can't be misclicked alongside Download / Delete. -->
-        <button
-          v-if="canFavorite"
-          type="button"
-          class="hero-eyebrow-star"
-          :class="{ 'is-on': favorited }"
-          :aria-pressed="favorited"
-          :aria-label="
-            favorited
-              ? $t('torrents.detail.favoriteRemove')
-              : $t('torrents.detail.favoriteAdd')
-          "
-          :title="
-            favorited
-              ? $t('torrents.detail.favoriteRemove')
-              : $t('torrents.detail.favoriteAdd')
-          "
-          @click="toggleFavorite"
-        >
-          <Icon :name="favorited ? 'ph:star-fill' : 'ph:star-bold'" />
-          <span class="hero-eyebrow-star-label">
-            {{ $t('torrents.detail.favorite') }}
-          </span>
-        </button>
-        <!-- Report button parked in the top-right corner of the hero
-             so it stays accessible (any authenticated user can flag)
-             without sitting next to the destructive Delete in the
-             main CTA row — flagging is cautionary, deletion is
-             permanent, the two shouldn't live shoulder-to-shoulder. -->
-        <button
-          v-if="canReport"
-          type="button"
-          class="hero-eyebrow-report"
-          @click="reportOpen = true"
-        >
-          <Icon name="ph:flag-bold" />
-          <span>{{ $t('torrents.detail.report') }}</span>
-        </button>
-      </header>
-
-      <h1
-        class="hero-title"
-        :data-len="heroTitleLen"
-        :title="torrent.name"
-      >
-        {{ withWrapHints(torrent.name) }}
-      </h1>
-
-      <div
-        v-if="
-          torrent.tags?.length ||
-          torrent.imdbId ||
-          torrent.tmdbId ||
-          torrent.tvdbId
-        "
-        class="hero-chips"
-      >
-        <NuxtLink
-          v-for="tag in torrent.tags"
-          :key="tag.id"
-          :to="`/torrents?tag=${encodeURIComponent(tag.slug)}`"
-          class="chip chip--tag"
-          :style="tagBadgeStyle(tag)"
-        >
-          <span class="chip-dot" :style="{ backgroundColor: tag.color }" />
-          {{ tag.name }}
-        </NuxtLink>
-
-        <a
-          v-if="torrent.imdbId"
-          :href="`https://www.imdb.com/title/${torrent.imdbId}/`"
-          target="_blank"
-          rel="noopener noreferrer"
-          class="media-id-badge media-id-badge--imdb"
-          :title="`IMDb · ${torrent.imdbId}`"
-        >
-          <span class="media-id-badge-tag">IMDb</span>
-          <span class="media-id-badge-id">{{ torrent.imdbId }}</span>
-          <Icon name="ph:arrow-up-right-bold" class="text-[10px]" />
-        </a>
-        <a
-          v-if="tmdbLink"
-          :href="tmdbLink.href"
-          target="_blank"
-          rel="noopener noreferrer"
-          class="media-id-badge media-id-badge--tmdb"
-          :title="`TMDb · ${tmdbLink.label}`"
-        >
-          <span class="media-id-badge-tag">TMDb</span>
-          <span class="media-id-badge-id">{{ tmdbLink.label }}</span>
-          <Icon name="ph:arrow-up-right-bold" class="text-[10px]" />
-        </a>
-        <a
-          v-if="torrent.tvdbId"
-          :href="`https://thetvdb.com/dereferrer/series/${torrent.tvdbId}`"
-          target="_blank"
-          rel="noopener noreferrer"
-          class="media-id-badge media-id-badge--tvdb"
-          :title="`TVDB · ${torrent.tvdbId}`"
-        >
-          <span class="media-id-badge-tag">TVDB</span>
-          <span class="media-id-badge-id">{{ torrent.tvdbId }}</span>
-          <Icon name="ph:arrow-up-right-bold" class="text-[10px]" />
-        </a>
-      </div>
-
-      <!-- Replaced BY something, said before the download button rather than
-           five sections below it.
-           This banner used to live down in the cross-seed section, carrying a
-           comment that read "a member who landed here should be told before they
-           press download, not after they scroll" — some 280 lines and two full
-           screens after the button. Deliberately not red: the release still
-           works and its swarm is untouched, and colouring a factual notice as a
-           danger would make members abandon a download that is fine. -->
-      <div v-if="supersessions?.supersededBy" class="supersede-banner">
-        <Icon name="ph:arrow-bend-right-up-bold" class="supersede-banner-icon" />
-        <div class="supersede-banner-body">
-          <p class="supersede-banner-lead">
-            {{ $t('torrents.detail.supersede.replacedBy') }}
-          </p>
-          <NuxtLink
-            :to="`/torrents/${supersessions?.supersededBy?.infoHash}`"
-            class="supersede-banner-link"
-          >
-            {{ supersessions?.supersededBy?.name }}
-          </NuxtLink>
-          <p v-if="supersessions?.supersededBy?.reason" class="supersede-banner-reason">
-            {{ supersessions?.supersededBy?.reason }}
-          </p>
-          <p class="supersede-banner-note">
-            {{ $t('torrents.detail.supersede.stillSeedable') }}
-          </p>
-        </div>
-      </div>
-
-      <!-- One bold primary action (Download) flanked by mono ghosts
-           for the destructive / reporting paths. The size carries the
-           weight of the file so a user can decide before clicking. -->
-      <div class="hero-cta">
-        <a
-          :href="`/api/torrents/${torrent.infoHash}/download`"
-          class="cta-primary"
-          download
-        >
-          <Icon name="ph:download-simple-bold" class="cta-primary-icon" />
-          <span class="cta-primary-stack">
-            <span class="cta-primary-label">{{ $t('torrents.detail.download') }}</span>
-            <span class="cta-primary-sub">{{ formatSize(torrent.size) }}</span>
-          </span>
-        </a>
-
-        <div class="hero-cta-aux">
-          <NuxtLink
-            v-if="canEdit"
-            :to="`/torrents/${torrent.infoHash}/edit`"
-            class="cta-ghost"
-          >
-            <Icon name="ph:pencil-simple-bold" />
-            <span>{{ $t('common.edit') }}</span>
-          </NuxtLink>
-          <button
-            v-if="canDelete"
-            type="button"
-            class="cta-ghost cta-ghost--danger"
-            @click="confirmDelete"
-          >
-            <Icon name="ph:trash-bold" />
-            <span>{{ $t('common.delete') }}</span>
-          </button>
-        </div>
-      </div>
-
-      <!-- Inline meta ribbon: hash · uploader · age. Replaces the
-           old three-card strip with a single horizontal data row,
-           dividers between cells, monospace throughout. -->
-      <dl class="hero-meta">
-        <div class="hero-meta-cell hero-meta-cell--hash">
-          <dt>{{ $t('torrents.detail.infoHash') }}</dt>
-          <dd>
-            <code class="hero-meta-hash">{{ torrent.infoHash }}</code>
-          </dd>
-        </div>
-        <div class="hero-meta-cell hero-meta-cell--uploader">
-          <dt>{{ $t('torrents.detail.uploadedBy') }}</dt>
-          <dd>
-            <NuxtLink
-              v-if="torrent.uploader"
-              :to="`/users/${torrent.uploader.id}`"
-              class="hero-meta-user"
-            >
-              <Icon name="ph:user-bold" class="hero-meta-user-icon" />
-              @{{ torrent.uploader.username }}
-            </NuxtLink>
-            <!-- A concealed uploader and a deleted one both arrive as a
-                 null `uploader`; only `uploaderAnonymous` separates them,
-                 and saying "Account deleted" about a member who is still
-                 here would be plainly wrong. -->
-            <span
-              v-else-if="torrent.uploaderAnonymous"
-              class="hero-meta-user hero-meta-user--anon"
-              :title="$t('torrents.detail.uploaderAnonymousTooltip')"
-            >
-              <Icon name="ph:user-bold" class="hero-meta-user-icon" />
-              {{ $t('torrents.detail.uploaderAnonymous') }}
-            </span>
-            <span
-              v-else
-              class="hero-meta-user hero-meta-user--gone"
-              :title="$t('torrents.detail.uploaderGoneTooltip')"
-            >
-              <Icon name="ph:user-bold" class="hero-meta-user-icon" />
-              {{ $t('torrents.detail.uploaderGone') }}
-            </span>
-          </dd>
-        </div>
-      </dl>
-    </section>
-
-    <!-- Rich metadata card. Picked by source so a game lands on the
-         IGDB card, a book on Open Library / Google Books, and a
-         movie/TV on TMDb. Silent no-op when the lookup missed. -->
-    <GameMetadataCard
-      v-if="metadata && metadata.source === 'igdb'"
-      :metadata="metadata"
-      class="release-metadata"
-    />
-    <BookMetadataCard
-      v-else-if="metadata && metadata.source === 'openlibrary'"
-      :metadata="metadata"
-      class="release-metadata"
-    />
-    <MediaMetadataCard
-      v-else-if="metadata"
-      :metadata="metadata"
-      class="release-metadata"
-    />
-
-    <!-- § NFO — sits right under the rich-metadata card so the technical
-         summary is one click away without scrolling past the stats. The
-         section uses the compact header variant: smaller `§` mark, a
-         single-line bar, no editorial display weight. The NFO is a
-         release-engineering artefact, not a piece of writing — it
-         shouldn't compete visually with the description below. -->
-    <section v-if="torrent.nfo" class="section section--compact section--nfo">
-      <header class="section-head section-head--compact section-head--toggle">
-        <button
-          type="button"
-          class="section-head-button"
-          :aria-expanded="nfoExpanded"
-          aria-controls="nfo-body"
-          @click="nfoExpanded = !nfoExpanded"
-        >
-          <span class="section-head-mark" aria-hidden="true">§</span>
-          <h2 class="section-head-title">{{ $t('torrents.detail.sections.nfo') }}</h2>
-          <span class="section-head-meta">{{ nfoMeta }}</span>
-          <Icon
-            name="ph:caret-right-bold"
-            class="section-head-caret"
-            :class="{ 'is-expanded': nfoExpanded }"
-          />
-        </button>
-        <button
-          v-if="nfoExpanded"
-          type="button"
-          class="section-head-action"
-          @click="copyNfo"
-        >
-          <Icon :name="nfoCopied ? 'ph:check-bold' : 'ph:copy-bold'" />
-          {{ nfoCopied ? $t('common.copied') : $t('common.copy') }}
-        </button>
-      </header>
-      <div v-show="nfoExpanded" id="nfo-body" class="nfo-frame">
-        <pre class="nfo-body">{{ torrent.nfo }}</pre>
-      </div>
-    </section>
-
-    <!-- ╔══════════════ § ACTIVITY ═══════════════╗
-         Instrument cluster — one continuous strip with five (or four)
-         metric cells, status-coloured numbers, inline x-seed sub
-         lines. Replaces the previous five-card grid which read as
-         five competing islands. -->
-    <section class="section section--activity">
-      <header class="section-head">
-        <span class="section-head-mark" aria-hidden="true">§</span>
-        <h2 class="section-head-title">{{ $t('torrents.detail.sections.activity') }}</h2>
-        <span class="section-head-line" aria-hidden="true" />
-      </header>
-      <ul class="stats-cluster">
-        <li class="stat stat--size">
-          <Icon name="ph:database-bold" class="stat-icon" />
-          <div class="stat-body">
-            <span class="stat-num">{{ formatSize(torrent.size) }}</span>
-            <span class="stat-label">{{ $t('torrents.detail.stats.totalSize') }}</span>
-          </div>
-        </li>
-        <li class="stat stat--seeders" :class="{ 'is-zero': torrent.stats.seeders === 0 }">
-          <Icon name="ph:arrow-up-bold" class="stat-icon" />
-          <div class="stat-body">
-            <span class="stat-num tabular-nums">{{ torrent.stats.seeders }}</span>
-            <span class="stat-label">{{ $t('torrents.detail.stats.seeders') }}</span>
-            <span v-if="xSeedSeederSub" class="stat-sub">{{ xSeedSeederSub }}</span>
-          </div>
-        </li>
-        <li class="stat stat--leechers" :class="{ 'is-zero': torrent.stats.leechers === 0 }">
-          <Icon name="ph:arrow-down-bold" class="stat-icon" />
-          <div class="stat-body">
-            <span class="stat-num tabular-nums">{{ torrent.stats.leechers }}</span>
-            <span class="stat-label">{{ $t('torrents.detail.stats.leechers') }}</span>
-            <span v-if="xSeedLeecherSub" class="stat-sub">{{ xSeedLeecherSub }}</span>
-          </div>
-        </li>
-        <li class="stat stat--completed">
-          <Icon name="ph:check-circle-bold" class="stat-icon" />
-          <div class="stat-body">
-            <span class="stat-num tabular-nums">{{ torrent.stats.completed }}</span>
-            <span class="stat-label">{{ $t('torrents.detail.stats.completed') }}</span>
-          </div>
-        </li>
-        <li v-if="showVolumeCard" class="stat stat--volume">
-          <Icon name="ph:cloud-arrow-up-bold" class="stat-icon" />
-          <div class="stat-body">
-            <span class="stat-num">{{ totalUploadedDisplay }}</span>
-            <span class="stat-label">{{ $t('torrents.detail.stats.exchanged') }}</span>
-            <span v-if="xSeedVolumeSub" class="stat-sub">{{ xSeedVolumeSub }}</span>
-          </div>
-        </li>
-      </ul>
-
-      <!-- A dead swarm used to be a zero and nothing else. The site knows who
-           downloaded this once, so the zero can lead somewhere. Hidden for a
-           superseded release: asking members to resurrect one works against a
-           decision staff already took. -->
-      <div v-if="canAskReseed" class="reseed-ask">
-        <p class="reseed-hint">
-          <Icon name="ph:hand-heart-bold" class="reseed-icon" />
-          {{ reseedResult ? $t(`torrents.detail.reseed.state.${reseedResult}`) : $t('torrents.detail.reseed.hint') }}
-        </p>
-        <button
-          v-if="!reseedResult"
-          type="button"
-          class="btn btn-secondary btn-sm"
-          :disabled="reseedBusy"
-          @click="askReseed"
-        >
-          <Icon
-            :name="reseedBusy ? 'ph:circle-notch' : 'ph:megaphone-bold'"
-            :class="{ 'animate-spin': reseedBusy }"
-          />
-          {{ reseedBusy ? $t('torrents.detail.reseed.asking') : $t('torrents.detail.reseed.ask') }}
-        </button>
-      </div>
-    </section>
-
-    <!-- § NOTE — uploader's description, when present. Treated as an
-         editorial pull-block: serif italic opening character, generous
-         line-height, no surrounding "card" frame. -->
-    <section v-if="torrent.description" class="section section--note">
-      <header class="section-head">
-        <span class="section-head-mark" aria-hidden="true">§</span>
-        <h2 class="section-head-title">{{ $t('torrents.detail.sections.note') }}</h2>
-        <span class="section-head-line" aria-hidden="true" />
-      </header>
-      <article class="note-block">
-        <DescriptionRender :source="torrent.description" />
-      </article>
-    </section>
-
-    <!-- § CROSS-SEEDS — sibling rips of the same content. Was a table,
-         now a list of compact rows so it reads as "related releases"
-         rather than tabular data. -->
-    <section
-      v-if="crossSeeds && crossSeeds.items.length > 0"
-      class="section section--cross"
-    >
-      <header class="section-head">
-        <span class="section-head-mark" aria-hidden="true">§</span>
-        <h2 class="section-head-title">
-          {{ $t('torrents.detail.sections.crossSeeds') }}
-        </h2>
-        <span class="section-head-count">{{ crossSeeds.items.length }}</span>
-        <span class="section-head-line" aria-hidden="true" />
-      </header>
-      <!-- The grouping is based on matching file names + sizes only
-           (a metadata fingerprint), NOT verified content — so it's a
-           discovery hint, never a guarantee these hold the same data. -->
-      <p class="cross-note">
-        <Icon name="ph:info-bold" class="cross-note-icon" />
-        {{ $t('torrents.detail.crossSeedNote') }}
-      </p>
-      <ul class="cross-list">
-        <li
-          v-for="sib in crossSeeds.items"
-          :key="sib.id"
-          class="cross-item"
-        >
-          <NuxtLink :to="`/torrents/${sib.infoHash}`" class="cross-link">
-            <Icon name="ph:arrows-left-right-bold" class="cross-icon" />
-            <span class="cross-name">{{ sib.name }}</span>
-            <span class="cross-meta">
-              <span class="cross-meta-cat">{{ sib.category?.name ?? '—' }}</span>
-              <span class="cross-meta-sep">·</span>
-              <span class="cross-meta-size">{{ formatSize(sib.size) }}</span>
-              <span class="cross-meta-sep">·</span>
-              <span class="cross-meta-age">{{ formatAge(sib.createdAt) }}</span>
-            </span>
-            <Icon name="ph:arrow-right-bold" class="cross-arrow" />
-          </NuxtLink>
-        </li>
-      </ul>
-    </section>
-
-    <!-- § SUPERSEDED — this release was replaced, or replaces others. Sits
-         with the cross-seed sections because it answers the same kind of
-         question (what else is this?), and reuses their markup so a reader
-         scanning the page meets one list format, not three. -->
-    <section v-if="supersessions?.supersedes.length" class="section section--cross">
-      <header class="section-head">
-        <span class="section-head-mark" aria-hidden="true">§</span>
-        <h2 class="section-head-title">{{ $t('torrents.detail.supersede.title') }}</h2>
-        <span class="section-head-line" aria-hidden="true" />
-      </header>
-
-      <!-- Replaced BY something is announced in the hero, above the download
-           button — see the banner there. What stays here is the other
-           direction. -->
-
-      <!-- Replaces others: informational, so it reads as the ordinary list. -->
-      <template v-if="supersessions.supersedes.length">
-        <p class="cross-note">
-          <Icon name="ph:info-bold" class="cross-note-icon" />
-          {{ $t('torrents.detail.supersede.replaces') }}
-        </p>
-        <ul class="cross-list">
-          <li v-for="old0 in supersessions.supersedes" :key="old0.infoHash" class="cross-item">
-            <NuxtLink :to="`/torrents/${old0.infoHash}`" class="cross-link">
-              <Icon name="ph:arrow-bend-left-down-bold" class="cross-icon" />
-              <span class="cross-name">{{ old0.name }}</span>
-              <span class="cross-meta">
-                <span class="cross-meta-size">{{ formatSize(old0.size) }}</span>
-                <template v-if="old0.supersedeReason">
-                  <span class="cross-meta-sep">·</span>
-                  <span class="cross-meta-cat">{{ old0.supersedeReason }}</span>
-                </template>
-              </span>
-              <Icon name="ph:arrow-right-bold" class="cross-arrow" />
-            </NuxtLink>
-          </li>
-        </ul>
-      </template>
-    </section>
-
-    <!-- § FEDERATED CROSS-SEED — same content on a partner (M2). If you also
-         have an account there, you can cross-seed it from the bytes you already
-         hold, fetched with your own partner passkey. -->
-    <section
-      v-if="federationEnabled && federatedCrossSeeds && federatedCrossSeeds.items.length > 0"
-      class="section section--cross"
-    >
-      <header class="section-head">
-        <span class="section-head-mark" aria-hidden="true">§</span>
-        <h2 class="section-head-title">
-          {{ $t('torrents.detail.sections.crossSeedsFederated') }}
-        </h2>
-        <span class="section-head-count">{{ federatedCrossSeeds.items.length }}</span>
-        <span class="section-head-line" aria-hidden="true" />
-      </header>
-      <p class="cross-note">
-        <Icon name="ph:info-bold" class="cross-note-icon" />
-        {{ $t('torrents.detail.crossSeedFederatedNote') }}
-        <span
-          v-if="federatedCrossSeeds.availability.seeders > 0"
-          class="cross-mesh"
-        >
-          <Icon name="ph:users-three-bold" />
-          {{ $t('torrents.detail.crossSeedMeshSeeders', { n: federatedCrossSeeds.availability.seeders }) }}
-        </span>
-      </p>
-      <ul class="cross-list">
-        <li v-for="m in federatedCrossSeeds.items" :key="m.id" class="cross-item">
-          <NuxtLink :to="`/federated/${m.id}`" class="cross-link">
-            <Icon name="ph:broadcast-bold" class="cross-icon" />
-            <span class="cross-name">{{ m.name }}</span>
-            <span class="cross-meta">
-              <span class="cross-meta-cat">{{ m.peerName }}</span>
-              <span class="cross-meta-sep">·</span>
-              <span class="cross-meta-seed">▲ {{ m.seeders }}</span>
-              <span class="cross-meta-sep">·</span>
-              <span class="cross-meta-size">{{ formatSize(m.size) }}</span>
-              <span class="cross-meta-sep">·</span>
-              <!-- "v2 root", not "verified": the root is a value the partner
-                   published about its own release, and nothing here checked it
-                   against their bytes. It is a strong match KEY — a v2 root is
-                   a hash of the content — and it is still their claim. The
-                   title says which. -->
-              <span
-                class="cross-badge"
-                :class="m.matchType === 'v2' ? 'cross-badge--verified' : 'cross-badge--hint'"
-                :title="m.matchType === 'v2' ? $t('torrents.detail.crossMatchV2Title') : $t('torrents.detail.crossMatchHintTitle')"
-              >
-                {{ m.matchType === 'v2' ? $t('torrents.detail.crossMatchVerified') : $t('torrents.detail.crossMatchHint') }}
-              </span>
-            </span>
-            <Icon name="ph:arrow-right-bold" class="cross-arrow" />
-          </NuxtLink>
-        </li>
-      </ul>
-    </section>
-
-    <!-- § FEDERATION SWARM — per-torrent opt-in (uploader / staff).
-         Hidden entirely when the instance is not federated: there is nothing
-         to share the swarm WITH, so offering the switch only invites the
-         question of why flipping it does nothing. -->
-    <section v-if="canEdit && federationEnabled" class="section">
-      <header class="section-head">
-        <span class="section-head-mark" aria-hidden="true">§</span>
-        <h2 class="section-head-title">{{ $t('torrents.detail.fedSwarm.title') }}</h2>
-        <span class="section-head-line" aria-hidden="true" />
-      </header>
-      <div style="display: flex; align-items: center; justify-content: space-between; gap: 1rem; flex-wrap: wrap;">
-        <p style="font-size: 0.8125rem; color: rgb(var(--fg-muted)); max-width: 62ch; line-height: 1.55; margin: 0;">
-          {{ $t('torrents.detail.fedSwarm.desc') }}
-        </p>
-        <button type="button" class="btn btn-secondary" :disabled="fedSwarmBusy" @click="toggleFedSwarm">
-          <Icon :name="fedSwarm ? 'ph:broadcast-bold' : 'ph:broadcast'" />
-          {{ fedSwarm ? $t('torrents.detail.fedSwarm.on') : $t('torrents.detail.fedSwarm.off') }}
-        </button>
-      </div>
-    </section>
-
-    <!-- § STAFF TOOLS — two blocks that share one thing: they are decisions
-         about a release rather than facts about it. Kept together so the page
-         has one operator area instead of three, and each block carries its own
-         gate. Pinning is editorial and any moderator may do it; the
-         multipliers mint credit and only an admin may. The form mirrors that
-         rather than hiding a 403 behind a button that looks available. -->
-    <section v-if="isStaff" class="section section--buffs">
-      <header class="section-head">
-        <span class="section-head-mark" aria-hidden="true">§</span>
-        <h2 class="section-head-title">{{ $t('torrents.detail.staffTools') }}</h2>
-        <span class="section-head-line" aria-hidden="true" />
-      </header>
-
-      <h3 class="staff-block-title">{{ $t('torrents.detail.buffs.title') }}</h3>
-      <p class="buffs-lede">{{ $t('torrents.detail.buffs.lede') }}</p>
-
-      <div class="buffs-grid">
-        <label class="buffs-field">
-          <span class="field-label">{{ $t('torrents.detail.buffs.download') }}</span>
-          <select v-model.number="buffForm.downloadMultiplier" class="input" :disabled="!user?.isAdmin">
-            <option :value="0">0× — {{ $t('torrent.buff.freeleech') }}</option>
-            <option :value="50">0.5× — {{ $t('torrent.buff.silverleech') }}</option>
-            <option :value="100">1× — {{ $t('torrents.detail.buffs.normal') }}</option>
-          </select>
-        </label>
-
-        <label class="buffs-field">
-          <span class="field-label">{{ $t('torrents.detail.buffs.upload') }}</span>
-          <select v-model.number="buffForm.uploadMultiplier" class="input" :disabled="!user?.isAdmin">
-            <option :value="100">1× — {{ $t('torrents.detail.buffs.normal') }}</option>
-            <option :value="150">1.5×</option>
-            <option :value="200">2× — {{ $t('torrent.buff.doubleUpload') }}</option>
-            <option :value="300">3×</option>
-          </select>
-        </label>
-
-        <label class="buffs-field">
-          <span class="field-label">{{ $t('torrents.detail.buffs.until') }}</span>
-          <input
-            v-model="buffForm.until"
-            type="datetime-local"
-            class="input"
-            :disabled="!user?.isAdmin"
-          />
-          <span class="buffs-hint">{{ $t('torrents.detail.buffs.untilHint') }}</span>
-        </label>
-
-        <label class="buffs-toggle">
-          <input v-model="buffForm.isSticky" type="checkbox" />
-          <span>{{ $t('torrents.detail.buffs.pin') }}</span>
-        </label>
-      </div>
-
-      <div class="buffs-actions">
-        <button type="button" class="btn btn-secondary" :disabled="buffBusy" @click="saveBuffs">
-          <Icon :name="buffBusy ? 'ph:circle-notch' : 'ph:check-bold'" :class="{ 'animate-spin': buffBusy }" />
-          {{ $t('torrents.detail.buffs.save') }}
-        </button>
-        <button
-          v-if="buff"
-          type="button"
-          class="btn-ghost"
-          :disabled="buffBusy || !user?.isAdmin"
-          @click="clearBuffs"
-        >
-          {{ $t('torrents.detail.buffs.clear') }}
-        </button>
-      </div>
-
-      <!-- Trumping. Takes the replacement's infohash because that is what a
-           moderator has in front of them — they are looking at the newer
-           release's page in the other tab. -->
-      <h3 class="staff-block-title staff-block-title--spaced">
-        {{ $t('torrents.detail.supersede.staffTitle') }}
-      </h3>
-      <p class="buffs-lede">{{ $t('torrents.detail.supersede.staffLede') }}</p>
-
-      <div v-if="supersessions?.supersededBy" class="buffs-actions">
-        <p class="buffs-lede" style="margin: 0">
-          {{ $t('torrents.detail.supersede.currently', { name: supersessions.supersededBy.name }) }}
-        </p>
-        <button type="button" class="btn-ghost" :disabled="supersedeBusy" @click="clearSupersede">
-          {{ $t('torrents.detail.supersede.clear') }}
-        </button>
-      </div>
-
-      <div v-else class="buffs-grid">
-        <label class="buffs-field" style="flex: 1 1 22rem">
-          <span class="field-label">{{ $t('torrents.detail.supersede.hashLabel') }}</span>
-          <input
-            v-model="supersedeForm.hash"
-            type="text"
-            class="input"
-            autocomplete="off"
-            spellcheck="false"
-            placeholder="40 hex"
-          />
-        </label>
-        <label class="buffs-field" style="flex: 1 1 16rem">
-          <span class="field-label">{{ $t('torrents.detail.supersede.reasonLabel') }}</span>
-          <input v-model="supersedeForm.reason" type="text" class="input" maxlength="500" />
-        </label>
-        <button
-          type="button"
-          class="btn btn-secondary"
-          :disabled="supersedeBusy || supersedeForm.hash.length !== 40"
-          @click="saveSupersede"
-        >
-          <Icon
-            :name="supersedeBusy ? 'ph:circle-notch' : 'ph:arrow-bend-right-up-bold'"
-            :class="{ 'animate-spin': supersedeBusy }"
-          />
-          {{ $t('torrents.detail.supersede.mark') }}
-        </button>
-      </div>
-    </section>
-
-    <!-- § SWARM — admin-only peer list. Operational data, kept as a
-         table because that's the format that scans best. -->
-    <section v-if="user?.isAdmin" class="section section--swarm">
-      <header class="section-head">
-        <span class="section-head-mark" aria-hidden="true">§</span>
-        <h2 class="section-head-title">
-          {{ $t('torrents.detail.sections.swarm') }}
-        </h2>
-        <span class="section-head-count">{{ torrent.peers.length }}</span>
-        <span
-          class="section-head-tag"
-          :title="$t('torrents.detail.swarm.adminOnlyTooltip')"
-        >
-          {{ $t('torrents.detail.swarm.adminOnly') }}
-        </span>
-        <span class="section-head-line" aria-hidden="true" />
-      </header>
-      <div class="swarm-frame">
-        <table class="swarm-table">
-          <thead>
-            <tr>
-              <th>{{ $t('torrents.detail.swarm.endpoint') }}</th>
-              <th>{{ $t('torrents.detail.swarm.type') }}</th>
-              <th>{{ $t('torrents.detail.swarm.uploaded') }}</th>
-              <th>{{ $t('torrents.detail.swarm.downloaded') }}</th>
-              <th class="text-right">{{ $t('torrents.detail.swarm.lastSeen') }}</th>
-            </tr>
-          </thead>
-          <tbody>
-            <tr v-if="torrent.peers.length === 0">
-              <td colspan="5" class="swarm-empty">
-                {{ $t('torrents.detail.swarm.empty') }}
-              </td>
-            </tr>
-            <tr v-for="peer in torrent.peers" :key="peer.id">
-              <td>
-                <span class="swarm-endpoint">{{ peer.id.slice(0, 12) }}…</span>
-                <span class="swarm-port">:{{ peer.port }}</span>
-              </td>
-              <td>
-                <span
-                  class="swarm-type"
-                  :class="peer.isSeeder ? 'swarm-type--seeder' : 'swarm-type--leecher'"
-                >
-                  <Icon
-                    :name="peer.isSeeder ? 'ph:arrow-up-bold' : 'ph:arrow-down-bold'"
-                    class="text-[8px]"
-                  />
-                  {{ peer.isSeeder ? $t('torrents.detail.swarm.seeder') : $t('torrents.detail.swarm.leecher') }}
-                </span>
-              </td>
-              <td class="swarm-num">{{ formatSize(peer.uploaded) }}</td>
-              <td class="swarm-num">{{ formatSize(peer.downloaded) }}</td>
-              <td class="swarm-num text-right">{{ formatAge(peer.lastSeen) }}</td>
-            </tr>
-          </tbody>
-        </table>
-      </div>
-    </section>
-
-    <!-- Moderation panel (bottom placement) — only when the row is
-         in a final state. For pending / changes_requested rows the
-         panel renders at the top instead, before the metadata. -->
-    <div v-if="!moderationOnTop" class="mt-8">
-      <TorrentModerationPanel
-        :hash="torrent.infoHash"
-        :status="(torrent.moderationStatus as 'pending' | 'accepted' | 'changes_requested' | 'rejected')"
-        :uploader-id="torrent.uploaderId ?? null"
-        @status-change="onModerationStatusChange"
-      />
-    </div>
-
-    <!-- Report modal — opened from the action bar above. Renders
-         only when the operator clicks the Report button (it's
-         teleported to body so it doesn't matter where in the tree
-         it sits). -->
-    <ReportModal
-      :is-open="reportOpen"
-      target-type="torrent"
-      :target-id="torrent.id"
-      :target-label="torrent.name"
-      @close="reportOpen = false"
-      @submitted="reportOpen = false"
-    />
-  </div>
-</template>
-
 <script setup lang="ts">
-import TorrentModerationBadge from '~/components/torrent/TorrentModerationBadge.vue';
-import TorrentModerationPanel from '~/components/torrent/TorrentModerationPanel.vue';
-import DescriptionRender from '~/components/DescriptionRender.vue';
-import { withWrapHints } from '~/utils/displayTitle';
-
-interface Peer {
-  id: string;
-  port: number;
-  isSeeder: boolean;
-  uploaded: number;
-  downloaded: number;
-  lastSeen: string;
-}
-
-interface Category {
-  id: string;
-  name: string;
-  slug: string;
-  newznabId?: number | null;
-}
-
-interface Tag {
-  id: string;
-  name: string;
-  slug: string;
-  color: string;
-}
-
-interface TorrentDetail {
-  id: string;
-  infoHash: string;
-  /** From `redactUploader`: the row has an uploader, who asked to be hidden.
-   *  It was read in the template and declared nowhere. */
-  uploaderAnonymous?: boolean;
-  name: string;
-  size: number;
-  description: string | null;
-  nfo: string | null;
-  uploaderId: string | null;
-  federateSwarm?: boolean;
-  // Eager-loaded by the detail endpoint, projected down to id +
-  // username so the header strip can render an @-link without
-  // leaking email / role bits onto the public payload.
-  uploader: { id: string; username: string } | null;
-  categoryId: string | null;
-  category: Category | null;
-  tags?: Tag[];
-  imdbId?: string | null;
-  tmdbId?: string | null;
-  tvdbId?: string | null;
-  igdbId?: string | null;
-  openlibraryId?: string | null;
-  createdAt: string;
-  // Moderation pipeline status. Sent on every detail fetch so the
-  // header badge + the inline panel can render without an extra
-  // round-trip.
-  moderationStatus?: 'pending' | 'accepted' | 'changes_requested' | 'rejected';
-  /**
-   * Per-torrent bonus buffs. Basis points ×100 as stored — `0` freeleech,
-   * `100` normal, `200` double upload — with `multipliersUntil` null when the
-   * buff has no end date.
-   *
-   * A lapsed buff is NOT neutralised in the payload: the row is sent as it is
-   * and the badge decides, so a staffer editing it sees the values that are
-   * actually stored rather than a helpful lie.
-   */
-  downloadMultiplier?: number;
-  uploadMultiplier?: number;
-  multipliersUntil?: string | null;
-  isSticky?: boolean;
-  stats: {
-    seeders: number;
-    leechers: number;
-    completed: number;
-  };
-  peers: Peer[];
-  // Server signals an adult-content gate by sending a minimal payload
-  // with this flag set. The full TorrentDetail fields are absent in
-  // that case — the template guards every dereference behind
-  // `!torrent.gatedAdult`.
-  gatedAdult?: boolean;
-}
-
-const { t, locale } = useI18n();
+import { parseMediaInfoText } from '~/utils/mediainfo';
+import { parseReleaseName } from '@trackarr/shared/releaseParse';
+/**
+ * La page d'un torrent.
+ *
+ * # Ce qu'elle était
+ *
+ * 3578 lignes dans un fichier, dont 51,9 % de CSS, pour rendre DEUX sections à
+ * un membre regardant un torrent accepté sans NFO ni description ni cross-seed.
+ * Neuf des onze sections étaient conditionnelles, gardées par 47 conditions.
+ * Sept `await` bloquaient le premier octet. Trois sections quasi identiques
+ * répondaient à la même question du lecteur. Et la chaîne `data-theme`
+ * n'apparaissait pas une seule fois : rien n'y réagissait au thème clair.
+ *
+ * # L'ordre, et pourquoi celui-là
+ *
+ * Un membre arrive pour répondre à cinq questions, dans cet ordre : qu'est-ce
+ * que c'est ; quelle release et est-ce la bonne pour moi ; puis-je la prendre
+ * et devrais-je ; qu'en disent les autres ; le reste. La page suit cet ordre,
+ * et tout ce qui sert à décider — identité, chips de qualité, taille, santé du
+ * swarm, ce que je dois encore, le bouton — tient au-dessus de la ligne de
+ * flottaison d'un écran de 900 px.
+ *
+ * Deux références mesurées consacrent 58 % et 71 % de leur page à une
+ * description d'uploader qui REDIT ce que le site sait déjà. Ici la donnée
+ * vérifiée prime : les chips viennent de `releaseChips.ts`, les pistes du
+ * MediaInfo, et la note de l'uploadeur redevient une légende.
+ *
+ * # Ce que la page gagne, qui existait déjà sans porte d'entrée
+ *
+ * Les commentaires (l'API les charge à chaque requête, la route POST et la
+ * notification existent, personne ne les affichait), les chips de qualité
+ * (`releaseChips.ts` n'était utilisé que par la ligne de LISTE), le lien vers
+ * la page de groupe (« toutes les versions de cette œuvre », déjà écrite,
+ * jamais reliée) et l'obligation de seed du membre (`hnr_tracking` la connaît
+ * depuis toujours).
+ */
 const route = useRoute();
-const hash = route.params.hash as string;
-
-// Length-based size bucket for the hero title. Scene release names
-// span a wide range (from "Cats.Eye.S02.MULTI.1080p..." at ~40 chars
-// to "ReZERO.Starting.Life...HAPPYRAT" at 100+), and the same `clamp`
-// value can't serve both. The bucket attribute drives a different
-// `clamp` per length tier in the scoped CSS — short titles get the
-// magazine treatment, long ones shrink so the line never overflows.
-
-// Render the gate's faux file path with the middle of the hash blacked
-// out. Showing the full hash would let a determined operator copy it
-// elsewhere; showing nothing would feel like an opaque error. Keeping
-// the first / last four hex chars preserves the impression of "yes,
-// there is a real document here, you just don't get to see it".
-const redactedHash = computed(() => {
-  const h = hash || '';
-  if (h.length <= 8) return h;
-  return `${h.slice(0, 4)}…${h.slice(-4)}`;
-});
+const hash = computed(() => String(route.params.hash || ''));
 
 const {
-  data: torrent,
+  torrent,
+  comments,
+  commentCount,
+  crossSeeds,
+  supersessions,
+  crossSeedStats,
+  federatedCrossSeeds,
+  obligation,
+  refreshObligation,
+  metadata,
+  metadataPending,
+  ready,
+  user,
+  loggedIn,
+  federationEnabled,
+  isStaff,
+  canEdit,
+  canDelete,
+  canReport,
+  canFavorite,
+  gated,
+  buff,
+  buffPair,
+  buffEndsIn,
+  tmdbLink,
+  groupKey,
+  moderationOnTop,
+  canAskReseed,
+  refreshTorrent,
+  refreshSupersessions,
   error,
-  refresh,
-} = await useFetch<TorrentDetail>(`/api/torrents/${hash}`);
-
-// Length bucket for the hero title's `data-len` attribute. Drives a
-// different `clamp` per tier in the scoped CSS so scene names (which
-// can run 100+ characters) shrink rather than overflow, while a tidy
-// "Cat's Eye" gets the full magazine treatment.
-const heroTitleLen = computed<'sm' | 'md' | 'lg' | 'xl'>(() => {
-  const len = (torrent.value && !torrent.value.gatedAdult ? torrent.value.name : '').length;
-  if (len >= 90) return 'xl';
-  if (len >= 60) return 'lg';
-  if (len >= 35) return 'md';
-  return 'sm';
-});
-
-// Cross-seed companions — sibling torrents with the same canonical
-// file list. Empty / 404 just means "no cross-seeds known" → the
-// section hides itself. We do this in a side useFetch rather than
-// embedding it into the main detail payload so a slow signature
-// lookup never blocks the page render.
-interface CrossSeedItem {
-  id: string;
-  infoHash: string;
-  name: string;
-  size: number;
-  moderationStatus: string;
-  createdAt: string;
-  category: { id: string; name: string; slug: string; type: string | null } | null;
-  uploader: { id: string; username: string } | null;
-}
-const { data: crossSeeds } = await useFetch<{
-  items: CrossSeedItem[];
-  total: number;
-}>(`/api/torrents/${hash}/cross-seeds`, {
-  default: () => ({ items: [], total: 0 }),
-});
-
-// Federated cross-seed matches (M2): the same content held by partners, for a
-// member who can seed it there too. Same non-blocking side-fetch pattern.
-interface FederatedCrossSeedItem {
-  id: string;
-  infoHash: string;
-  name: string;
-  size: number;
-  seeders: number;
-  leechers: number;
-  peerName: string;
-  detailUrl: string | null;
-  matchType: 'v2' | 'signature';
-}
-// `branding` is fetched by the layout on every page, so reading it here is
-// free — and it carries whether this instance is federated at all.
-const branding = await useBranding();
-const federationEnabled = computed(() =>
-  Boolean(branding.value?.federationEnabled),
-);
-
-/**
- * Both directions of the trump pointer. A fourth side fetch beside the
- * cross-seed ones, non-blocking for the same reason: the page must render
- * whether or not this endpoint answers, and a hidden section is the right
- * degradation.
- */
-const { data: supersessions, refresh: refreshSupersessions } = await useFetch<{
-  supersededBy: {
-    infoHash: string;
-    name: string;
-    size: number;
-    at: string | null;
-    reason: string | null;
-  } | null;
-  supersedes: Array<{
-    infoHash: string;
-    name: string;
-    size: number;
-    supersedeReason: string | null;
-  }>;
-}>(`/api/torrents/${hash}/supersessions`, {
-  default: () => ({ supersededBy: null, supersedes: [] }),
-});
-
-const { data: federatedCrossSeeds } = await useFetch<{
-  items: FederatedCrossSeedItem[];
-  total: number;
-  availability: { releases: number; seeders: number; leechers: number };
-}>(`/api/torrents/${hash}/cross-seeds-federated`, {
-  // immediate: a non-federated instance has no partners to match against, and
-  // this fires on every torrent page view.
-  immediate: federationEnabled.value,
-  default: () => ({
-    items: [],
-    total: 0,
-    availability: { releases: 0, seeders: 0, leechers: 0 },
-  }),
-});
-
-// Cross-seed KPIs (peer counts + volume share). Same side-fetch
-// pattern as `crossSeeds` above — the qualifier chips on the stats
-// row stay hidden until this resolves, no skeleton needed.
-interface CrossSeedStats {
-  otherTorrentCount: number;
-  seederCount: number;
-  leecherCount: number;
-  uploadedShareBytes: string;
-  totalUploadedBytes: string;
-}
-const { data: crossSeedStats } = await useFetch<CrossSeedStats>(
-  `/api/torrents/${hash}/cross-seed-stats`,
-  {
-    default: () => ({
-      otherTorrentCount: 0,
-      seederCount: 0,
-      leecherCount: 0,
-      uploadedShareBytes: '0',
-      totalUploadedBytes: '0',
-    }),
-  },
-);
-
-// Sub-text helpers — empty string → StatsCard renders no qualifier.
-const xSeedSeederSub = computed(() => {
-  const n = crossSeedStats.value?.seederCount ?? 0;
-  return n > 0 ? `${n} x-seed` : '';
-});
-const xSeedLeecherSub = computed(() => {
-  const n = crossSeedStats.value?.leecherCount ?? 0;
-  return n > 0 ? `${n} x-seed` : '';
-});
-const totalUploadedDisplay = computed(() => {
-  const raw = crossSeedStats.value?.totalUploadedBytes ?? '0';
-  // BigInt round-trip preserves precision past 2^53 bytes.
-  const bytes = Number(BigInt(raw));
-  return formatSize(bytes);
-});
-const xSeedVolumeSub = computed(() => {
-  const total = crossSeedStats.value?.totalUploadedBytes ?? '0';
-  const share = crossSeedStats.value?.uploadedShareBytes ?? '0';
-  const totalNum = Number(BigInt(total));
-  const shareNum = Number(BigInt(share));
-  if (totalNum === 0 || shareNum === 0) return '';
-  const pct = (shareNum / totalNum) * 100;
-  // Round to 1 decimal for sub-1% values, integer otherwise — keeps
-  // the chip narrow while staying honest about tiny shares.
-  const formatted = pct < 1 ? pct.toFixed(1) : Math.round(pct).toString();
-  return `${formatted}% x-seed`;
-});
-const showVolumeCard = computed(() => {
-  return Number(BigInt(crossSeedStats.value?.totalUploadedBytes ?? '0')) > 0;
-});
-
-/**
- * Sync the local torrent reactive when the moderation panel pushes a
- * status transition (approve / reject / etc.). Saves us from
- * re-fetching the whole detail payload just to refresh the badge.
+} = useTorrentDetail(hash.value);
+
+/*
+ * L'attente est ICI et pas dans le composable, et c'est structurel : le
+ * compilateur de Vue enveloppe les `await` de premier niveau d'un
+ * `<script setup>` dans `withAsyncContext()`, qui rétablit l'instance du
+ * composant après la reprise. Un fichier `.ts` n'a pas ce filet — l'attendre
+ * là-bas rendait `NUXT_E1001`, donc un 500, au rendu serveur seulement.
  */
-function onModerationStatusChange(
-  next: 'pending' | 'accepted' | 'changes_requested' | 'rejected'
-) {
-  if (torrent.value && !torrent.value.gatedAdult) {
-    torrent.value.moderationStatus = next;
-  }
-}
-
-/**
- * Drives the placement of the moderation panel.
- *   - pending / changes_requested  → top of the page (the uploader
- *     has something to read or to do; we don't want them scrolling
- *     past every byte of metadata to find it)
- *   - accepted / rejected          → bottom of the page (the matter
- *     is closed; the conversation is reference material rather than
- *     a call to action)
+await ready;
+/*
+ * Rien à afficher : l'erreur du site, comme avant la refonte — un hash inconnu,
+ * une release retirée ou refusée ne doivent pas rendre une page vide en 200.
  *
- * The component itself is rendered exactly once on either side of
- * the layout via mutually-exclusive v-ifs so the API call doesn't
- * fire twice.
+ * Le statut de l'amont est repris tel quel : annoncer « release introuvable »
+ * sur une API en panne envoie chercher une release qui existe.
  */
-const moderationOnTop = computed(() => {
-  const status = torrent.value && !torrent.value.gatedAdult
-    ? torrent.value.moderationStatus
-    : null;
-  return status === 'pending' || status === 'changes_requested';
-});
-
-// Pick whichever external id the uploader supplied. TMDb's /find
-// covers IMDb / TVDB; IGDB serves video games. Order in
-// `lookupParams` matters: a movie/TV-hinted torrent prefers TMDb
-// even when an IGDB id is also stored.
-/* The shared wire type. This page declared its own copy with `source`
- * optional, which is not what the route returns and is exactly what the
- * three cards below reject. See `packages/shared/src/media.ts`. */
-import type { MediaMetadata } from '@trackarr/shared/media';
-interface MediaMetadataResponse {
-  enabled: boolean;
-  found: boolean;
-  metadata: MediaMetadata | null;
-}
-
-// Derive an external metadata hint from the torrent's category — a
-// category mapped under the Newznab `Movies` parent (2xxx) implies
-// a movie, `TV` (5xxx) implies a series, Console (1xxx) or PC games
-// (4xxx) imply a video game. The hint stops the lookup from
-// guessing the wrong namespace when the same numeric id exists in
-// both. Falls back to a slug/name heuristic so custom French
-// categories (`Films Français`, `Séries Françaises`, `Jeux`, …)
-// stay classified even without a newznab_id.
-function deriveTypeHint(
-  cat:
-    | { newznabId?: number | null; slug?: string; name?: string }
-    | null
-    | undefined
-): 'movie' | 'tv' | 'game' | 'book' | undefined {
-  const id = cat?.newznabId;
-  if (typeof id === 'number') {
-    if (id >= 5000 && id < 6000) return 'tv';
-    if (id >= 2000 && id < 3000) return 'movie';
-    // Newznab buckets 1xxx (Console games) and 4xxx (PC) both map
-    // to IGDB. We treat them as the same `game` hint — IGDB indexes
-    // every platform under one game id.
-    if ((id >= 1000 && id < 2000) || (id >= 4000 && id < 5000)) return 'game';
-    // 7xxx is the book/ebook/comic/magazine decade.
-    if (id >= 7000 && id < 8000) return 'book';
-  }
-  const text = `${cat?.slug || ''} ${cat?.name || ''}`
-    .toLowerCase()
-    .normalize('NFD')
-    .replace(/[̀-ͯ]/g, '');
-  if (/\b(?:tv|seri|episod|saison|season|show|anime)/.test(text)) return 'tv';
-  if (/\b(?:movie|film|cinema|cine)/.test(text)) return 'movie';
-  if (/\b(?:game|games|jeu|jeux|console|playstation|xbox|nintendo|switch|pc-?game)/.test(text)) return 'game';
-  if (/\b(?:book|ebook|e-book|epub|mobi|azw3|livre|livres|comics?|bd|manga|magazine|revue)/.test(text)) return 'book';
-  return undefined;
+if (error.value || !torrent.value) {
+  const upstream = Number((error.value as { statusCode?: number } | null)?.statusCode) || 404;
+  throw createError({
+    statusCode: upstream,
+    statusMessage: upstream === 404 ? 'Torrent not found' : 'Torrent unavailable',
+    fatal: true,
+  });
 }
 
-const lookupParams = computed(() => {
-  const t = torrent.value;
-  if (!t) return null;
-  const type = deriveTypeHint(t.category);
-  // Prefer the source that matches the category hint when we have
-  // multiple ids stored — a TV box with both a TMDb and an IGDB id
-  // should hit TMDb, a book box with both an Open Library and TMDb
-  // id should hit Open Library, and so on.
-  if (type === 'book' && t.openlibraryId) {
-    return { source: 'openlibrary', id: t.openlibraryId, type };
-  }
-  if (type === 'game' && t.igdbId) {
-    return { source: 'igdb', id: t.igdbId, type };
-  }
-  if (t.tmdbId) return { source: 'tmdb', id: t.tmdbId, type };
-  if (t.imdbId) return { source: 'imdb', id: t.imdbId, type };
-  if (t.tvdbId) return { source: 'tvdb', id: t.tvdbId, type };
-  if (t.igdbId) return { source: 'igdb', id: t.igdbId, type };
-  if (t.openlibraryId)
-    return { source: 'openlibrary', id: t.openlibraryId, type };
-  return null;
-});
-
-const { data: metadataResponse } = await useFetch<MediaMetadataResponse>(
-  '/api/metadata/lookup',
-  {
-    // useFetch refetches when reactive query params change.
-    query: computed(() => {
-      const p = lookupParams.value;
-      if (!p) return {};
-      const out: Record<string, string> = { source: p.source, id: p.id };
-      if (p.type) out.type = p.type;
-      return out;
-    }),
-    // Skip the call entirely when there's nothing to look up — saves
-    // the 503 response when the operator hasn't set TMDB_API_KEY.
-    immediate: !!lookupParams.value,
-    watch: [lookupParams],
-    // Don't surface a 5xx to the page error boundary; the metadata
-    // card just won't render and the rest of the page works.
-    onResponseError({ response }) {
-      if (response.status === 503) return;
-    },
-  }
-);
-
-const metadata = computed(
-  () => metadataResponse.value?.metadata ?? null
-);
-
-// Get current user session
-const { loggedIn, user } = useUserSession();
-
-
-// Phase 4 — per-torrent swarm-federation opt-in (uploader / staff only).
-const fedSwarm = ref(false);
-const fedSwarmBusy = ref(false);
-watch(
-  () => torrent.value?.federateSwarm,
-  (v) => {
-    fedSwarm.value = !!v;
-  },
-  { immediate: true },
-);
-async function toggleFedSwarm() {
-  const enabled = !fedSwarm.value;
-  const hash = torrent.value?.infoHash;
-  if (!hash) return;
-  fedSwarmBusy.value = true;
-  try {
-    await $fetch(`/api/torrents/${hash}/federate-swarm`, {
-      method: 'PUT',
-      body: { enabled },
-    });
-    fedSwarm.value = enabled;
-  } catch {
-    /* keep previous visual state on error */
-  } finally {
-    fedSwarmBusy.value = false;
-  }
-}
+const { t } = useI18n();
 const notifications = useNotificationStore();
 const confirm = useConfirm();
 
 /**
- * The buff this release carries on its own, or null.
+ * Un titre d'onglet, enfin.
  *
- * Mirrors `apps/api/utils/torrentBuffs.buffLabel` — same four names, same
- * "lapsed reads as none" rule. Duplicated here rather than sent pre-computed
- * because the staff panel below edits the raw numbers, and a payload carrying
- * both the numbers and a label derived from them is a payload with two answers
- * to one question.
+ * La page n'avait aucune gestion d'en-tête — ni `useHead`, ni `useSeoMeta`, ni
+ * `definePageMeta`. Chaque torrent partageait le titre par défaut du site, et
+ * un lien partagé ne disait pas ce qu'il pointait.
  */
-const buff = computed(() => {
-  const t0 = torrent.value;
-  if (!t0 || t0.downloadMultiplier === undefined || t0.uploadMultiplier === undefined) {
-    return null;
-  }
-  const lapsed = !!t0.multipliersUntil && new Date(t0.multipliersUntil) <= new Date();
-  if (lapsed) return null;
-  const dl = t0.downloadMultiplier;
-  const ul = t0.uploadMultiplier;
-  if (dl === 100 && ul === 100) return null;
-
-  const kind =
-    dl === 0 && ul === 100
-      ? 'freeleech'
-      : dl === 50 && ul === 100
-        ? 'silverleech'
-        : dl === 100 && ul === 200
-          ? 'doubleUpload'
-          : 'custom';
-  const icon =
-    kind === 'freeleech'
-      ? 'ph:gift-fill'
-      : kind === 'silverleech'
-        ? 'ph:gift'
-        : kind === 'doubleUpload'
-          ? 'ph:arrow-fat-lines-up-fill'
-          : 'ph:sparkle-fill';
-  return { kind, icon, until: t0.multipliersUntil ?? null, dl, ul };
-});
-
-/** "0.25× DL · 2× UL" — the multipliers a `custom` buff refuses to name. */
-const buffPair = computed(() => {
-  if (!buff.value) return '';
-  const f = (percent: number) => `${(percent / 100).toLocaleString(locale.value)}×`;
-  return `${f(buff.value.dl)} DL · ${f(buff.value.ul)} UL`;
+useSeoMeta({
+  title: () =>
+    gated.value
+      ? t('torrents.detail.adultGate.metaTitle')
+      : (torrent.value?.name ?? t('torrents.detail.metaFallback')),
+  // Le texte brut de la note contient du BBCode ou du Markdown : les balises
+  // et la ponctuation de mise en forme n'ont rien à faire dans une description.
+  description: () =>
+    gated.value
+      ? ''
+      : (torrent.value?.description ?? '')
+          .replace(/\[\/?[a-z*][^\]]*\]|<[^>]*>/gi, ' ')
+          .replace(/[#*_>`|]+/g, ' ')
+          .replace(/\s+/g, ' ')
+          .trim()
+          .slice(0, 160),
+  robots: 'noindex',
 });
 
-/**
- * How long the buff has left, or nothing.
- *
- * `formatAge` was being asked this and answering "just now" for every date in
- * the future, so a freeleech with three days on it advertised itself as
- * already over. `formatUntil` is the forward-looking one, and it returns an
- * empty string once the deadline has passed — which is also the moment the
- * badge should stop claiming a deadline at all.
- */
-const buffEndsIn = computed(() =>
-  buff.value?.until ? formatUntil(buff.value.until, locale.value) : ''
-);
-
-const isStaff = computed(
-  () => !!user.value && (user.value.isAdmin || user.value.isModerator)
-);
+/* ── Actions ─────────────────────────────────────────────────────────────── */
 
-/**
- * The staff form's own state, seeded from the row and NOT bound to it.
+const favorited = ref(false);
+const favoriteBusy = ref(false);
+/*
+ * `viewerFavorited` et non `favorited` : c'est le nom que la route projette
+ * (`[hash].get.ts`), et lire l'autre laissait le drapeau à `false` à chaque
+ * chargement. Conséquence visible : le favori était bien enregistré, mais au
+ * rechargement l'étoile revenait vide et un clic RÉ-ajoutait ce qui y était
+ * déjà. Rien ne pouvait l'attraper — un champ absent d'un `Record<string,
+ * any>` est `undefined`, pas une erreur de type.
  *
- * A `datetime-local` input wants `YYYY-MM-DDTHH:mm` in local time, while the
- * row carries an ISO instant — so the two cannot share a ref without one of
- * them being wrong. Seeding once and converting on save keeps the conversion
- * in one place.
+ * Le garde `if (torrent.value)` n'est pas décoratif : pendant un
+ * `refreshTorrent()`, `torrent.value` repasse brièvement à `undefined` et,
+ * sans lui, cet effet écrasait l'état optimiste par `false`.
  */
-const buffForm = reactive({
-  downloadMultiplier: 100,
-  uploadMultiplier: 100,
-  until: '',
-  isSticky: false,
+watchEffect(() => {
+  if (torrent.value) favorited.value = Boolean(torrent.value.viewerFavorited);
 });
-const buffBusy = ref(false);
 
-watch(
-  torrent,
-  (t0) => {
-    if (!t0) return;
-    buffForm.downloadMultiplier = t0.downloadMultiplier ?? 100;
-    buffForm.uploadMultiplier = t0.uploadMultiplier ?? 100;
-    buffForm.isSticky = t0.isSticky ?? false;
-    // `isoToDatetimeLocal` plutôt que `toISOString().slice(0, 16)` : cette
-    // dernière écrivait l'heure UTC dans un champ qui la relit comme locale,
-    // donc l'échéance reculait d'un fuseau à chaque enregistrement.
-    buffForm.until = isoToDatetimeLocal(t0.multipliersUntil);
-  },
-  { immediate: true }
-);
-
-async function putBuffs(body: Record<string, unknown>) {
-  buffBusy.value = true;
+async function toggleFavorite() {
+  if (!torrent.value || favoriteBusy.value) return;
+  favoriteBusy.value = true;
+  const was = favorited.value;
+  favorited.value = !was;
   try {
-    await $fetch(`/api/mod/torrents/${hash}/buffs`, { method: 'PUT', body });
-    await refresh();
-    notifications.success(t('torrents.detail.buffs.saved'));
-  } catch (err: unknown) {
-    const e = err as { data?: { message?: string }; message?: string };
-    notifications.error(e?.data?.message || e?.message || t('torrents.detail.buffs.failed'));
+    await $fetch(`/api/torrents/${torrent.value.infoHash}/favorite`, {
+      method: was ? 'DELETE' : 'POST',
+    });
+    notifications.success(
+      t(was ? 'torrents.detail.toasts.unfavorited' : 'torrents.detail.toasts.favorited'),
+    );
+  } catch (err: any) {
+    favorited.value = was;
+    notifications.error(
+      err?.data?.message || t('torrents.detail.toasts.favoriteFailed'),
+    );
   } finally {
-    buffBusy.value = false;
-  }
-}
-
-function saveBuffs() {
-  // A moderator may only send the pin — the multipliers would be refused, and
-  // sending them anyway would turn every pin into a 403.
-  if (!user.value?.isAdmin) {
-    return putBuffs({ isSticky: buffForm.isSticky });
+    favoriteBusy.value = false;
   }
-  return putBuffs({
-    downloadMultiplier: buffForm.downloadMultiplier,
-    uploadMultiplier: buffForm.uploadMultiplier,
-    until: datetimeLocalToIso(buffForm.until),
-    isSticky: buffForm.isSticky,
-  });
-}
-
-function clearBuffs() {
-  return putBuffs({ downloadMultiplier: 100, uploadMultiplier: 100, until: null });
 }
 
-/**
- * Offered only when the swarm is genuinely dead and the release is still the
- * current one. The server checks both again — this is about not showing a
- * button that will be refused, not about trusting the client.
- */
 const reseedBusy = ref(false);
-const canAskReseed = computed(
-  () =>
-    loggedIn.value &&
-    !!torrent.value &&
-    !torrent.value.gatedAdult &&
-    torrent.value.stats?.seeders === 0 &&
-    !supersessions.value?.supersededBy
-);
-
-/**
- * What the last reseed request did, so the button can stop offering itself.
- *
- * `null` means "not asked in this visit"; anything else replaces the control
- * with the outcome. Pressing it used to leave the button in its ordinary
- * enabled state with nothing on the page recording that the ask had happened —
- * and since the cooldown is site-wide and daily, the next member to press it
- * got a 429 for a slot somebody else had already used.
- */
 const reseedResult = ref<'asked' | 'nobody' | 'already' | null>(null);
 
 async function askReseed() {
   reseedBusy.value = true;
   try {
     const res = await $fetch<{ notified: number }>(
-      `/api/torrents/${hash}/reseed-request`,
-      { method: 'POST' }
+      `/api/torrents/${hash.value}/reseed-request`,
+      { method: 'POST' },
     );
-    // Nought notified is not a success. It consumed the day's one slot and
-    // told the member it had worked.
+    // Zéro notifié n'est pas un succès : la demande a consommé le seul créneau
+    // du jour et annonçait pourtant que c'était fait.
     if (res.notified === 0) {
       reseedResult.value = 'nobody';
       notifications.error(t('torrents.detail.reseed.nobody'));
@@ -1500,2079 +188,1059 @@ async function askReseed() {
       reseedResult.value = 'asked';
       notifications.success(t('torrents.detail.reseed.done', res.notified));
     }
-  } catch (err: unknown) {
-    const e = err as { statusCode?: number; data?: { message?: string }; message?: string };
-    // Mapped on the status, not echoed from the body. `reseed-request` answers
-    // a 429 with an English sentence written for a developer — "A reseed has
-    // already been requested for this torrent today." — and echoing
-    // `e.data.message` put that English into a French page.
-    if (e?.statusCode === 429) {
-      reseedResult.value = 'already';
-      notifications.error(t('torrents.detail.reseed.already'));
-    } else {
-      notifications.error(t('torrents.detail.reseed.failed'));
-    }
+  } catch (err: any) {
+    if (err?.statusCode === 429) reseedResult.value = 'already';
+    notifications.error(err?.data?.message || t('torrents.detail.reseed.failed'));
   } finally {
     reseedBusy.value = false;
   }
 }
 
-const supersedeForm = reactive({ hash: '', reason: '' });
-const supersedeBusy = ref(false);
-
-async function saveSupersede() {
-  supersedeBusy.value = true;
+async function confirmDelete() {
+  if (!torrent.value) return;
+  const ok = await confirm({
+    title: t('torrents.detail.deleteConfirm.title'),
+    message: t('torrents.detail.deleteConfirm.message', { name: torrent.value.name }),
+    confirmText: t('common.delete'),
+    destructive: true,
+  });
+  if (!ok) return;
   try {
-    await $fetch(`/api/mod/torrents/${hash}/supersede`, {
-      method: 'PUT',
-      body: {
-        supersededById: supersedeForm.hash.trim().toLowerCase(),
-        reason: supersedeForm.reason.trim() || undefined,
-      },
-    });
-    supersedeForm.hash = '';
-    supersedeForm.reason = '';
-    await refreshSupersessions();
-    notifications.success(t('torrents.detail.supersede.saved'));
-  } catch (err: unknown) {
-    const e = err as { data?: { message?: string }; message?: string };
-    notifications.error(
-      e?.data?.message || e?.message || t('torrents.detail.supersede.failed')
-    );
-  } finally {
-    supersedeBusy.value = false;
+    await $fetch(`/api/torrents/${torrent.value.infoHash}`, { method: 'DELETE' });
+    notifications.success(t('torrents.detail.toasts.deleted'));
+    await navigateTo('/torrents');
+  } catch (err: any) {
+    notifications.error(err?.data?.message || t('torrents.detail.toasts.deleteFailed'));
   }
 }
 
-async function clearSupersede() {
-  supersedeBusy.value = true;
-  try {
-    await $fetch(`/api/mod/torrents/${hash}/supersede`, { method: 'DELETE' });
-    await refreshSupersessions();
-    notifications.success(t('torrents.detail.supersede.cleared'));
-  } catch (err: unknown) {
-    const e = err as { data?: { message?: string }; message?: string };
-    notifications.error(
-      e?.data?.message || e?.message || t('torrents.detail.supersede.failed')
-    );
-  } finally {
-    supersedeBusy.value = false;
+/**
+ * Le clic sur le bouton.
+ *
+ * La route de téléchargement crée la ligne d'obligation, mais la carte ne
+ * change d'état qu'à la PREMIÈRE annonce du client — `downloaded` reste à zéro
+ * tant qu'aucun octet n'a été rapporté (mesuré : relue 1,2 s après le clic, la
+ * ligne dit encore « pas encore téléchargée »). Ouvrir le fichier dans un
+ * client prend dix secondes à deux minutes ; on relit donc l'obligation à 20,
+ * 45, 80 et 120 s, et on s'arrête dès qu'elle bouge. Quatre requêtes au plus,
+ * pour que « en cours » et son balayage arrivent sous les yeux du membre.
+ */
+const takenTimers: ReturnType<typeof setTimeout>[] = [];
+function onTaken() {
+  for (const t of takenTimers) clearTimeout(t);
+  takenTimers.length = 0;
+  for (const ms of [20_000, 45_000, 80_000, 120_000]) {
+    takenTimers.push(setTimeout(async () => {
+      if (obligation.value?.downloaded) return;
+      await refreshObligation();
+    }, ms));
   }
 }
+onBeforeUnmount(() => { for (const t of takenTimers) clearTimeout(t); });
 
-// Compute permissions
-const canEdit = computed(() => {
-  if (!loggedIn.value || !user.value) return false;
-  const isOwner = torrent.value?.uploaderId === user.value.id;
-  return isOwner || user.value.isAdmin || user.value.isModerator;
+/** La teinte de l'œuvre, remontée par le héros pour le cadre de la décision. */
+const workTint = ref<string | null>(null);
+/*
+ * La fiche ouverte entre dans « vu récemment », que la barre du catalogue
+ * propose quand le champ est vide. Huit entrées, dans le navigateur seulement.
+ */
+onMounted(() => {
+  const tor = toValue(torrent) as { infoHash?: string; name?: string } | null | undefined;
+  if (!tor?.infoHash || !tor.name) return;
+  try {
+    const raw = localStorage.getItem('trackarr.recentlyViewed');
+    const list = raw ? (JSON.parse(raw) as Array<{ hash: string; title: string }>) : [];
+    const rest = Array.isArray(list) ? list.filter((x) => x && x.hash !== tor.infoHash) : [];
+    localStorage.setItem('trackarr.recentlyViewed', JSON.stringify([{ hash: tor.infoHash, title: tor.name }, ...rest].slice(0, 8)));
+  } catch {
+    /* stockage indisponible : rien de plus */
+  }
 });
-
-const canDelete = computed(() => {
-  if (!loggedIn.value || !user.value) return false;
-  const isOwner = torrent.value?.uploaderId === user.value.id;
-  return isOwner || user.value.isAdmin || user.value.isModerator;
+/*
+ * La teinte calculée ici part au cache des métadonnées, pour que les cartes du
+ * catalogue la portent sans refaire l'image : une fiche ouverte une fois
+ * colore l'œuvre partout. Silencieux si l'API refuse — la fiche a sa couleur.
+ */
+/** La charge utile filtrée porte `category.name`, la fiche complète `categoryName` : les deux. */
+const gatedCategoryName = computed(() => {
+  const t = toValue(torrent) as { category?: { name?: string | null } | null; categoryName?: string | null } | null | undefined;
+  return t?.category?.name ?? t?.categoryName ?? null;
 });
+function onTint(rgb: string | null) {
+  workTint.value = rgb;
+  if (!rgb) return;
+  const tor = toValue(torrent) as { tmdbId?: string | null; igdbId?: string | null; openlibraryId?: string | null } | null | undefined;
+  const source = tor?.tmdbId ? 'tmdb' : tor?.igdbId ? 'igdb' : tor?.openlibraryId ? 'openlibrary' : null;
+  const id = tor?.tmdbId ?? tor?.igdbId ?? tor?.openlibraryId ?? null;
+  if (!source || !id) return;
+  void $fetch('/api/metadata/tint', { method: 'POST', body: { source, id, tint: rgb } }).catch(() => {
+    /* pas de teinte au catalogue cette fois ; la prochaine fiche réessaiera */
+  });
+}
 
-// Report a torrent — any authenticated user can file one. The
-// uploader can technically report their own upload; moderators will
-// dismiss the obvious self-reports. Keeping the gate that permissive
-// avoids confusing edge cases ("why is the button hidden?") and
-// trusts the moderation queue to filter noise.
-const canReport = computed(() => loggedIn.value && !!user.value);
-
-const reportOpen = ref(false);
-
-// Favorite toggle. The server's `viewerFavorited` projection is
-// the source of truth on initial load; `favorited` mirrors it
-// optimistically so the star flips instantly on click without
-// waiting for the round-trip. A failed POST/DELETE rolls back
-// the optimistic state and surfaces a toast.
-const canFavorite = computed(() => loggedIn.value && !!user.value);
-const favorited = ref<boolean>(false);
-const favoriteBusy = ref(false);
-watchEffect(() => {
-  if (torrent.value) {
-    favorited.value = Boolean((torrent.value as any).viewerFavorited);
-  }
-});
-
-async function toggleFavorite() {
-  if (!torrent.value || favoriteBusy.value) return;
-  favoriteBusy.value = true;
-  const wasFavorited = favorited.value;
-  favorited.value = !wasFavorited;
-  try {
-    await $fetch(`/api/torrents/${torrent.value.infoHash}/favorite`, {
-      method: wasFavorited ? 'DELETE' : 'POST',
-    });
-    notifications.success(
-      wasFavorited
-        ? t('torrents.detail.toasts.unfavorited')
-        : t('torrents.detail.toasts.favorited'),
-    );
-  } catch (err: any) {
-    favorited.value = wasFavorited;
-    notifications.error(
-      err?.data?.message || t('torrents.detail.toasts.favoriteFailed'),
-    );
-  } finally {
-    favoriteBusy.value = false;
-  }
-}
+/**
+ * Le sommaire : une barre qui GLISSE d'une entrée à l'autre au lieu de
+ * sauter. Mesurée sur le lien actif à chaque changement ; `transform`, donc
+ * aucune mise en page.
+ */
+const tocLinks = new Map<string, HTMLElement>();
+function setTocLink(id: string, el: unknown) {
+  if (el instanceof HTMLElement) tocLinks.set(id, el); else tocLinks.delete(id);
+}
+const tocBar = ref<{ transform: string; height: string } | null>(null);
+function placeTocBar() {
+  const el = tocLinks.get(activeSection.value);
+  tocBar.value = el ? { transform: `translateY(${el.offsetTop}px)`, height: `${el.offsetHeight}px` } : null;
+}
 
 /**
- * Build the badge target for a TMDb id.
- *
- * The stored value can be a bare integer ("121361") or a prefixed form
- * ("tv/121361" / "movie/121361") — see `normalizeTmdbId`. Without the
- * helper we used to hardcode `/movie/` in the URL, which produced
- * `https://www.themoviedb.org/movie/tv/57243` for prefixed ids and
- * landed on a broken page.
+ * La note se plie et se déplie en hauteur (200 ms) au lieu de sauter. La
+ * hauteur cible est mesurée, posée en style pendant la transition, puis
+ * retirée : la classe reprend la main. Sous « réduire les animations », le
+ * changement est immédiat.
  */
-const tmdbLink = computed(() => {
-  const raw = torrent.value?.tmdbId;
-  if (!raw) return null;
-  const prefixed = raw.match(/^(movie|tv)\/(\d+)$/);
-  if (prefixed) {
-    const [, type, id] = prefixed;
-    return {
-      href: `https://www.themoviedb.org/${type}/${id}`,
-      label: id,
-    };
+const noteBody = ref<HTMLElement | null>(null);
+function toggleNote() {
+  const el = noteBody.value;
+  const fold = !noteFolded.value;
+  if (!el) {
+    noteFolded.value = fold;
+    return;
   }
-  // Bare digits — fall back to the type the lookup hint resolves to,
-  // otherwise `/movie/` (TMDb redirects to the right namespace anyway).
-  const fallbackType = lookupParams.value?.type ?? 'movie';
-  return {
-    href: `https://www.themoviedb.org/${fallbackType}/${raw}`,
-    label: raw,
-  };
-});
-
-function tagBadgeStyle(tag: { color: string }) {
-  // Tint the chip background with the tag's color while keeping the
-  // foreground readable in either theme. Falls back to neutral on any
-  // unparseable input.
-  const hex = (tag.color || '').replace('#', '');
-  const valid = /^[0-9a-f]{6}$/i.test(hex);
-  if (!valid) {
-    return {
-      backgroundColor: 'rgb(var(--bg-elevated))',
-      borderColor: 'rgb(var(--line-default))',
-      color: 'rgb(var(--fg-default))',
-    };
+  // La durée se lit sur la transition une fois posée, pas sur le jeton : la
+  // valeur calculée d'une propriété personnalisée reste « calc(200ms * 1) »,
+  // que `parseFloat` ne sait pas lire. Sous « réduire les animations », la
+  // règle globale la ramène à 0,01 ms : c'est le chemin immédiat.
+  el.style.transition = 'max-height var(--dur-4) var(--ease-emphasis)';
+  const ms = (parseFloat(getComputedStyle(el).transitionDuration) || 0) * 1000;
+  if (ms < 20) {
+    el.style.transition = '';
+    noteFolded.value = fold;
+    return;
   }
-  return {
-    backgroundColor: `#${hex}1a`, // ~10% alpha
-    borderColor: `#${hex}66`, // ~40% alpha
-    color: 'rgb(var(--fg-default))',
+  const full = el.scrollHeight;
+  const clamp = Math.min(full, 26 * parseFloat(getComputedStyle(document.documentElement).fontSize));
+  el.style.maxHeight = `${fold ? full : clamp}px`;
+  el.style.overflow = 'hidden';
+  // Le point de départ doit être CALCULÉ avant la cible, sinon la transition
+  // part de « none » — qui ne s'anime pas — et le repli saute (mesuré : 3114
+  // → 416 px en une image). Lire la hauteur force ce calcul.
+  void el.offsetHeight;
+  noteFolded.value = fold;
+  let done = false;
+  const finish = () => {
+    if (done) return;
+    done = true;
+    el.style.transition = ''; el.style.maxHeight = ''; el.style.overflow = '';
+    el.removeEventListener('transitionend', finish);
   };
+  el.style.maxHeight = `${fold ? clamp : full}px`;
+  el.addEventListener('transitionend', finish);
+  setTimeout(finish, ms + 80);
 }
 
-if (error.value || !torrent.value) {
-  throw createError({ statusCode: 404, message: t('torrents.detail.notFound') });
+const reportOpen = ref(false);
+/** Le motif prérempli quand le signalement vient de « Mauvaise fiche ? ». */
+const reportPreset = ref<string | null>(null);
+function reportMetadata() {
+  reportPreset.value = t('components.report.reasons.wrongMetadata');
+  reportOpen.value = true;
 }
-
-const nfoCopied = ref(false);
-const nfoExpanded = ref(false);
-async function copyNfo() {
-  if (!torrent.value?.nfo) return;
-  await navigator.clipboard.writeText(torrent.value.nfo);
-  nfoCopied.value = true;
-  setTimeout(() => (nfoCopied.value = false), 1500);
+function closeReport() {
+  reportOpen.value = false;
+  reportPreset.value = null;
 }
 
-const nfoMeta = computed(() => {
-  const txt = torrent.value?.nfo;
-  if (!txt) return '';
-  const lines = txt.split('\n').length;
-  const bytes = new Blob([txt]).size;
-  const size =
-    bytes >= 1024 ? `${(bytes / 1024).toFixed(1)} KB` : `${bytes} B`;
-  return `${t('torrents.detail.nfoMeta.lines', { n: lines })} · ${size}`;
+/**
+ * Le fil d'orientation : catégorie › œuvre › unité.
+ *
+ * L'œuvre n'y figure QUE si un fournisseur l'a nommée — sinon le titre du
+ * héros la dit déjà — et elle mène à la page du groupe, c'est-à-dire à toutes
+ * ses releases. L'unité reprend les libellés de la barre d'unité du tableau,
+ * pour que « Saison 01 · Épisode 09 » s'écrive pareil aux deux endroits.
+ */
+const pad2 = (n: number) => String(n).padStart(2, '0');
+const heroCrumbs = computed(() => {
+  const tor = torrent.value;
+  if (!tor) return [];
+  const out: Array<{ label: string; to?: string | null; minor?: boolean }> = [];
+  // Le catalogue filtre sur `?c=<id>` — pas sur le slug.
+  const cat = tor.category as { id?: string; name?: string } | null | undefined;
+  if (cat?.name) out.push({ label: cat.name, to: cat.id ? `/torrents?c=${encodeURIComponent(cat.id)}` : null });
+  const work = metadata.value?.title;
+  // `minor` : le héros le titre déjà — sur un téléphone, le fil s'en passe.
+  if (work && groupKey.value) out.push({ label: work, to: `/torrents/group/${groupKey.value}`, minor: true });
+  const parts: string[] = [];
+  if (typeof tor.season === 'number') parts.push(t('search.group.season', { n: pad2(tor.season) }));
+  if (typeof tor.episode === 'number') parts.push(t('torrents.detail.versions.unit.episodeValue', { n: pad2(tor.episode) }));
+  if (parts.length) out.push({ label: parts.join(' · ') });
+  return out;
 });
 
-async function confirmDelete() {
-  if (!torrent.value) return;
-  const ok = await confirm({
-    title: t('torrents.detail.deleteConfirm.title'),
-    message: t('torrents.detail.deleteConfirm.message', { name: torrent.value.name }),
-    confirmText: t('common.delete'),
-    destructive: true,
-  });
-  if (!ok) return;
-
-  try {
-    await $fetch(`/api/torrents/${torrent.value!.infoHash}`, {
-      method: 'DELETE',
-    });
-    notifications.success(t('torrents.detail.toasts.deleted'));
-    await navigateTo('/torrents');
-  } catch (err: unknown) {
-    const fetchError = err as { data?: { message?: string }; message?: string };
-    notifications.error(
-      fetchError.data?.message ||
-        fetchError.message ||
-        t('torrents.detail.errors.deleteFailed')
-    );
+/**
+ * Deux raccourcis, annoncés dans la carte des actions : `D` télécharge, `F`
+ * met en favori. Jamais quand on écrit (champ, zone de texte, éditeur), jamais
+ * avec un modificateur — `Ctrl+F` reste la recherche du navigateur, qui est
+ * précisément ce que la case « tout afficher » sert.
+ */
+function onShortcut(e: KeyboardEvent) {
+  if (e.metaKey || e.ctrlKey || e.altKey) return;
+  // Une touche maintenue déclenchait un téléchargement par répétition clavier ;
+  // une composition (IME) ne tape pas une lettre ; et une boîte modale ouverte
+  // (signalement, confirmation) a le clavier pour elle.
+  if (e.repeat || e.isComposing) return;
+  if (document.querySelector('[role="dialog"][aria-modal="true"]')) return;
+  const el = e.target as HTMLElement | null;
+  if (el && (el.matches('input, textarea, select, [contenteditable=""], [contenteditable="true"]') || el.isContentEditable)) return;
+  if (e.key === 'd' || e.key === 'D') {
+    const cta = document.querySelector<HTMLAnchorElement>('.release-aside .dlc');
+    if (cta) { e.preventDefault(); cta.click(); }
+  } else if ((e.key === 'f' || e.key === 'F') && canFavorite.value) {
+    e.preventDefault();
+    void toggleFavorite();
   }
 }
+onMounted(() => window.addEventListener('keydown', onShortcut));
+onBeforeUnmount(() => window.removeEventListener('keydown', onShortcut));
 
-</script>
-
-<style scoped>
-/* ╔══════════════════════════════════════════════════════════════╗
-   ║  RELEASE PRESS SHEET — torrent detail page                  ║
-   ║  Type pairing: Source Serif 4 (display) + JetBrains Mono    ║
-   ║                (every label / number / chip)                ║
-   ║  Color discipline: --accent dominant, --online / --warning  ║
-   ║                /--danger reserved for status semantics       ║
-   ╚══════════════════════════════════════════════════════════════╝ */
-
-.release-page {
-  position: relative;
-  max-width: 1180px;
-  margin: 0 auto;
-  padding: 2rem 1.5rem 5rem;
-  isolation: isolate;
-  /* Local hue spectrum. The page distributes distinct colours so no
-     two adjacent UI elements ever share a tint — the eye reads each
-     chip/button as its own identity instead of "another blue".
-     Violet / rose / teal are scoped here; the rest pull from the
-     global semantic vars (online/warning/danger/info/accent). */
-  --release-purple: 167 139 250;
-  --release-cyan:   var(--info);
-  --release-rose:   244 114 182;
-  --release-teal:   45 212 191;
-}
-
-/* ── Atmospheric background ──────────────────────────────────────
-   Three layers: a deep indigo ambient at the top of the page that
-   tints the otherwise neutral --bg-base toward "night sky"; two
-   coloured blobs picking up the accent + the violet metadata hue;
-   and a faint dot-grid pattern for texture. The combination keeps
-   the page dark (it stays a dark theme) but warms it enough to feel
-   "rich" rather than just "operator console". */
-.release-aura {
-  /* fixed, not absolute: the page wrapper is a centred max-width column, so an
-     absolute backdrop was clipped to it and stopped short of the viewport on
-     every side. Matches .shop-bg, which already had this right. */
-  position: fixed;
-  /* Break out of the centred 1180-px wrapper to span the full
-     viewport width: anchor at left:50% then pull back by 50 vw with
-     a negative margin so the aura's left/right edges line up with
-     the viewport's. The aura clips its own blob children
-     (`overflow: hidden`); mobile is safe because the aura's outer
-     width is exactly 100 vw — no fractional bleed that could
-     trigger a stray right-scroll. */
-  top: -2rem;
-  left: 50%;
-  width: 100vw;
-  margin-left: -50vw;
-  height: 70vh;
-  z-index: -1;
-  overflow: hidden;
-  pointer-events: none;
-}
-.release-aura::before {
-  content: '';
-  position: absolute;
-  inset: 0;
-  background:
-    radial-gradient(
-      ellipse 80% 60% at 30% 0%,
-      rgba(56, 89, 178, 0.28),
-      transparent 70%
-    ),
-    radial-gradient(
-      ellipse 60% 50% at 80% 0%,
-      rgb(var(--release-purple) / 0.18),
-      transparent 70%
-    );
-}
-.aura-blob {
-  position: absolute;
-  display: block;
-  filter: blur(80px);
-  opacity: 0.38;
-  border-radius: 50%;
-}
-.aura-blob--a {
-  width: 520px;
-  height: 520px;
-  top: -180px;
-  left: -120px;
-  background: radial-gradient(
-    circle,
-    rgb(var(--accent) / 0.55),
-    transparent 65%
-  );
-}
-.aura-blob--b {
-  width: 420px;
-  height: 420px;
-  top: 60px;
-  right: -160px;
-  background: radial-gradient(
-    circle,
-    rgb(var(--release-purple) / 0.55),
-    transparent 65%
-  );
-}
-.aura-grain {
-  position: absolute;
-  inset: 0;
-  background-image:
-    radial-gradient(rgba(255, 255, 255, 0.035) 1px, transparent 1px);
-  background-size: 3px 3px;
-  opacity: 0.55;
-  mix-blend-mode: overlay;
-}
-
-.release-back {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.5rem;
-  margin-bottom: 1.75rem;
-  font-family: var(--font-mono);
-  font-size: 0.625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.22em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-  transition: color var(--dur-2) ease, transform var(--dur-4) var(--ease-emphasis);
-}
-.release-back:hover {
-  color: rgb(var(--fg-strong));
-  transform: translateX(-2px);
-}
-
-/* ╔═══════════════════════════════════════════════════════════════╗
-   ║  HERO                                                          ║
-   ╚═══════════════════════════════════════════════════════════════╝ */
-.hero {
-  position: relative;
-  margin-bottom: 2.5rem;
-  padding: 1.75rem 1.85rem 1.5rem;
-  /* Layered background:
-     1. solid elevated surface as the base — non-translucent so the
-        hero unmistakably reads as its own card against the page (the
-        previous translucent fill made card and page blend into the
-        same dark plane);
-     2. tinted indigo + violet radial washes on top, picking up the
-        page's atmospheric blobs without losing the card identity. */
-  background:
-    radial-gradient(
-      ellipse 90% 100% at 0% 0%,
-      rgba(56, 89, 178, 0.22),
-      transparent 60%
-    ),
-    radial-gradient(
-      ellipse 70% 100% at 100% 100%,
-      rgb(var(--release-purple) / 0.18),
-      transparent 60%
-    ),
-    rgb(var(--bg-surface));
-  border: 1px solid rgb(var(--line-strong));
-  border-radius: var(--radius-xl);
-  overflow: hidden;
-  box-shadow:
-    0 22px 60px -22px rgb(var(--shadow-color) / calc(0.7 * var(--shadow-strength))),
-    0 4px 14px -8px rgb(var(--shadow-color) / calc(0.5 * var(--shadow-strength))),
-    inset 0 1px 0 rgba(255, 255, 255, 0.06);
-  animation: heroRise calc(0.65s * var(--motion-scale)) var(--ease-emphasis) both;
-}
-@keyframes heroRise {
-  from { opacity: 0; transform: translateY(8px); }
-  to   { opacity: 1; transform: translateY(0); }
-}
-/* Vertical status tab on the left edge — accent for accepted rows
-   (the common case), warning amber for pending / changes_requested,
-   danger red for rejected. Gives the hero the feel of a tabbed
-   physical document. */
-.hero::before {
-  content: '';
-  position: absolute;
-  inset: 0 auto 0 0;
-  width: 4px;
-  background: rgb(var(--hero-tab, var(--accent)));
-  opacity: 0.9;
-}
-.hero--status-pending,
-.hero--status-changes_requested { --hero-tab: var(--warning); }
-.hero--status-rejected { --hero-tab: var(--danger); }
-.hero--status-accepted { --hero-tab: var(--accent); }
-
-.hero-eyebrow {
-  display: flex;
-  align-items: center;
-  gap: 0.7rem;
-  flex-wrap: wrap;
-  margin-bottom: 1.1rem;
-  font-family: var(--font-mono);
-  font-size: 0.6563rem;
-  font-weight: 700;
-  letter-spacing: calc(0.24em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-  animation: heroFadeIn calc(0.55s * var(--motion-scale)) calc(0.05s * var(--motion-scale)) ease-out both;
-}
-.hero-eyebrow-mark {
-  font-family: var(--font-display);
-  font-style: italic;
-  font-size: 1.125rem;
-  font-weight: 600;
-  letter-spacing: 0;
-  color: rgb(var(--release-cyan));
-  line-height: 0;
-  transform: translateY(2px);
-  filter: drop-shadow(0 0 8px rgb(var(--release-cyan) / 0.4));
-}
-.hero-eyebrow-label {
-  color: rgb(var(--release-cyan));
-  font-weight: 800;
-}
-.hero-eyebrow-sep { opacity: 0.5; }
-.hero-eyebrow-date {
-  font-variant-numeric: tabular-nums;
-  color: rgb(var(--fg-default));
-  font-weight: 700;
-}
-.hero-eyebrow-spacer {
-  flex: 1 1 auto;
-  min-width: 1ch;
-}
-.hero-eyebrow-report {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.4rem;
-  padding: 0.32rem 0.7rem;
-  font-family: var(--font-mono);
-  font-size: 0.625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.2em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--warning));
-  background: rgb(var(--warning) / 0.1);
-  border: 1px solid rgb(var(--warning) / 0.5);
-  border-radius: var(--radius-sm);
-  cursor: pointer;
-  transition:
-    color var(--dur-2),
-    background var(--dur-2),
-    border-color var(--dur-2),
-    transform var(--dur-3) ease;
-}
-.hero-eyebrow-report:hover {
-  color: rgb(var(--bg-base));
-  background: rgb(var(--warning));
-  border-color: rgb(var(--warning));
-  transform: translateY(-1px);
-}
-
-/* ── Favorite star ────────────────────────────────────────
-   Mirrors the report chip's footprint so the two affordances
-   read as a matched pair, but uses an amber/gold tone (the
-   "library / catalog" colour we picked for the favorites
-   surface) instead of the warning tone. Outline state stays
-   muted so the star doesn't shout for attention; on-state
-   fills the glyph and ignites a glow.
-
-   The 0.55 s pop on activation gives the user a tactile
-   confirmation without needing a separate toast. */
-.hero-eyebrow-star {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.4rem;
-  padding: 0.32rem 0.7rem;
-  font-family: var(--font-mono);
-  font-size: 0.625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.2em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-  background: rgb(var(--bg-elevated));
-  border: 1px solid rgb(var(--line-strong));
-  border-radius: var(--radius-sm);
-  cursor: pointer;
-  transition:
-    color var(--dur-3),
-    background var(--dur-3),
-    border-color var(--dur-3),
-    transform var(--dur-4) var(--ease-emphasis);
-}
-.hero-eyebrow-star:hover {
-  color: rgb(var(--accent-warm-text));  /* jeton sémantique : cette teinte était figée sur le thème sombre */
-  border-color: rgba(245, 158, 11, 0.55);
-  background: rgba(245, 158, 11, 0.08);
-  transform: translateY(-1px);
-}
-.hero-eyebrow-star.is-on {
-  color: rgb(var(--accent-warm-text));  /* jeton sémantique : cette teinte était figée sur le thème sombre */
-  background: rgba(245, 158, 11, 0.16);
-  border-color: rgba(245, 158, 11, 0.65);
-  box-shadow:
-    inset 0 0 0 1px rgba(245, 158, 11, 0.25),
-    0 6px 16px -8px rgba(245, 158, 11, 0.55);
-}
-.hero-eyebrow-star.is-on svg {
-  filter: drop-shadow(0 0 6px rgba(245, 158, 11, 0.55));
-  animation: hero-star-pop calc(0.55s * var(--motion-scale)) cubic-bezier(0.34, 1.56, 0.64, 1);
-}
-@keyframes hero-star-pop {
-  0%   { transform: scale(1) rotate(0); }
-  35%  { transform: scale(1.45) rotate(-12deg); }
-  60%  { transform: scale(0.92) rotate(8deg); }
-  100% { transform: scale(1) rotate(0); }
-}
-
-.hero-title {
-  margin: 0 0 1rem;
-  font-family: var(--font-sans);
-  font-weight: 800;
-  letter-spacing: calc(-0.02em * var(--tracking-scale));
-  color: rgb(var(--fg-strong));
-  line-height: 1.12;
-  overflow-wrap: anywhere;
-  text-wrap: pretty;
-  animation: heroFadeIn 0.55s var(--dur-2) ease-out both;
-  /* Length-based size buckets — scaled down from the previous
-     "magazine hero" range so the title sits proportionate to the
-     hero, not overpowering it. Short titles still get presence; long
-     scene names shrink rather than wrap into walls. */
-  font-size: clamp(1.4rem, 3.6vw, 2.25rem); /* default = sm bucket */
-}
-.hero-title[data-len='md'] { font-size: clamp(1.25rem, 2.8vw, 1.75rem); }
-.hero-title[data-len='lg'] { font-size: clamp(1.1rem, 2.2vw, 1.45rem); }
-.hero-title[data-len='xl'] { font-size: clamp(0.95rem, 1.8vw, 1.2rem); }
-
-@keyframes heroFadeIn {
-  from { opacity: 0; transform: translateY(6px); }
-  to   { opacity: 1; transform: translateY(0); }
-}
-
-.hero-chips {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 0.5rem;
-  margin-bottom: 1.4rem;
-  animation: heroFadeIn 0.55s var(--dur-4) ease-out both;
-}
-.chip {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.4rem;
-  padding: 0.35rem 0.7rem;
-  border-radius: var(--radius-sm);
-  font-family: var(--font-mono);
-  font-size: 0.625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.16em * var(--tracking-scale));
-  text-transform: uppercase;
-  border: 1px solid rgb(var(--line-default));
-  color: rgb(var(--fg-default));
-  background: rgb(var(--bg-elevated) / 0.45);
-  transition: background var(--dur-2), border-color var(--dur-2), transform var(--dur-4);
-}
-.chip:hover {
-  background: rgb(var(--bg-elevated) / 0.75);
-  border-color: rgb(var(--fg-default) / 0.25);
-}
-.chip-icon {
-  font-size: 0.6875rem;
-  opacity: 0.75;
-}
-.chip--tag {
-  text-decoration: none;
-}
-.chip--tag:hover {
-  transform: translateY(-1px);
-}
-.chip-dot {
-  width: 6px;
-  height: 6px;
-  border-radius: var(--radius-pill);
-  display: inline-block;
-  flex-shrink: 0;
-}
-
-.hero-cta {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: stretch;
-  gap: 0.6rem 0.85rem;
-  margin-bottom: 1.5rem;
-  animation: heroFadeIn 0.55s var(--dur-slow) ease-out both;
-}
-.cta-primary {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.9rem;
-  padding: 0.85rem 1.35rem 0.85rem 1.1rem;
-  /* Green download — the colour reads as "go, available" the way a
-     traffic-light green does, which matches the C411 / classic
-     tracker convention. Diverges from the app's neutral accent on
-     purpose: download is the one action everyone reaches for, so it
-     gets the strongest visual signal on the page. */
-  background: linear-gradient(
-    135deg,
-    rgb(var(--online)),
-    rgb(var(--online) / 0.78)
-  );
-  color: rgb(var(--online-fg));  /* jeton sémantique : cette teinte était figée sur le thème sombre */
-  border-radius: var(--radius-lg);
-  text-decoration: none;
-  font-family: var(--font-mono);
-  font-weight: 800;
-  letter-spacing: calc(0.06em * var(--tracking-scale));
-  box-shadow:
-    0 16px 42px -22px rgb(var(--online) / 0.85),
-    inset 0 0 0 1px rgba(255, 255, 255, 0.12);
-  transition:
-    transform var(--dur-4) var(--ease-emphasis),
-    box-shadow var(--dur-4) ease,
-    filter var(--dur-3) ease;
-}
-.cta-primary:hover {
-  transform: translateY(-2px);
-  filter: brightness(1.08);
-  box-shadow:
-    0 20px 50px -20px rgb(var(--online) / 1),
-    inset 0 0 0 1px rgba(255, 255, 255, 0.18);
-}
-.cta-primary:active { transform: translateY(0); }
-.cta-primary-icon { font-size: 1.45rem; }
-.cta-primary-stack {
-  display: inline-flex;
-  flex-direction: column;
-  align-items: flex-start;
-  line-height: 1.05;
-}
-.cta-primary-label {
-  font-size: 0.8125rem;
-  font-weight: 800;
-  letter-spacing: calc(0.18em * var(--tracking-scale));
-  text-transform: uppercase;
-}
-.cta-primary-sub {
-  margin-top: 0.2rem;
-  font-size: 0.5938rem;
-  font-weight: 700;
-  letter-spacing: calc(0.18em * var(--tracking-scale));
-  text-transform: uppercase;
-  opacity: 0.78;
-  font-variant-numeric: tabular-nums;
-}
-
-.hero-cta-aux {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 0.45rem;
-}
-/* Edit takes violet so it doesn't repeat the cyan that already lives
-   in the eyebrow § mark. The action palette is now one button per
-   colour: green (Download), violet (Edit), red (Delete), amber
-   (Report) — four distinct hues, no near-doubles. */
-.cta-ghost {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.45rem;
-  padding: 0.6rem 0.95rem;
-  background: rgb(var(--release-purple) / 0.12);
-  border: 1px solid rgb(var(--release-purple) / 0.5);
-  border-radius: var(--radius-md);
-  font-family: var(--font-mono);
-  font-size: 0.6875rem;
-  font-weight: 700;
-  letter-spacing: calc(0.18em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--release-purple));
-  text-decoration: none;
-  cursor: pointer;
-  transition:
-    color var(--dur-2),
-    border-color var(--dur-2),
-    background-color var(--dur-2),
-    transform var(--dur-4);
-}
-.cta-ghost:hover {
-  /* Encre foncée : blanc sur ce violet mesure 2,72:1 dans les DEUX thèmes,
-     la valeur étant un littéral local qui ne bascule pas. */
-  color: rgb(var(--bg-base));
-  border-color: rgb(var(--release-purple));
-  background: rgb(var(--release-purple));
-  transform: translateY(-1px);
-}
-/* Destructive variants. Delete keeps the full red (it's irreversible);
-   Report drops to warning amber because filing a flag is cautionary,
-   not destructive — and the colour split breaks up the action row so
-   the eye can tell the two apart at a glance. */
-.cta-ghost--danger {
-  color: rgb(var(--danger));
-  border-color: rgb(var(--danger) / 0.55);
-  background: rgb(var(--danger) / 0.1);
-}
-.cta-ghost--danger:hover {
-  color: rgb(var(--danger-fg));  /* jeton sémantique : cette teinte était figée sur le thème sombre */
-  border-color: rgb(var(--danger));
-  background: rgb(var(--danger));
-  transform: translateY(-1px);
-}
-
-/* ── Meta ribbon ────────────────────────────────────────────────
-   Two chips on one horizontal row:
-     - hash     → neutral     (the fingerprint is just text — a
-                               coloured tint here read as semantic
-                               weight it didn't deserve)
-     - uploader → rose         (warm hue, identifies a person and
-                                does not collide with any action
-                                colour above)
-   The created-at chip moved out: the eyebrow now carries that data
-   as a relative duration ("6D AGO"), so a second copy in the
-   ribbon was redundant chrome. */
-.hero-meta {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: stretch;
-  gap: 0.55rem;
-  margin: 0;
-  padding: 0;
-  animation: heroFadeIn calc(0.55s * var(--motion-scale)) calc(0.4s * var(--motion-scale)) ease-out both;
-}
-.hero-meta-cell {
-  display: flex;
-  align-items: center;
-  gap: 0.65rem;
-  padding: 0.55rem 0.85rem;
-  background:
-    linear-gradient(
-      rgb(var(--rail, var(--fg-muted)) / 0.14),
-      rgb(var(--rail, var(--fg-muted)) / 0.14)
-    ),
-    rgb(var(--bg-elevated));
-  border: 1px solid rgb(var(--rail, var(--fg-muted)) / 0.5);
-  border-radius: var(--radius-md);
-  min-width: 0;
-  transition: border-color var(--dur-3) ease;
-}
-.hero-meta-cell:hover {
-  border-color: rgb(var(--rail, var(--fg-muted)) / 0.75);
-}
-.hero-meta-cell--hash {
-  /* Hash is a piece of pure data, not a status; treat it as neutral
-     chrome — the chip is still framed and still selectable, just no
-     colour signal beyond that. Sized to its content so it doesn't
-     stretch and dominate the row. */
-  --rail: var(--fg-muted);
-  flex: 0 0 auto;
-}
-.hero-meta-cell--hash {
-  background: rgb(var(--bg-elevated));
-  border-color: rgb(var(--line-strong));
-}
-.hero-meta-cell--hash:hover {
-  border-color: rgb(var(--fg-default) / 0.4);
-}
-.hero-meta-cell--uploader {
-  --rail: var(--release-rose);
-  /* Push to the right of the row so the hash (left) and the uploader
-     (right) bookend the ribbon — leaves the gap in the middle as
-     visual breathing room. Falls below on narrow viewports where the
-     wrap pushes the cell to its own line. */
-  margin-left: auto;
-}
-.hero-meta-cell dt {
-  font-family: var(--font-mono);
-  font-size: 0.5625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.22em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--rail, var(--fg-muted)));
-  margin: 0;
-  flex-shrink: 0;
-  opacity: 0.9;
-}
-.hero-meta-cell--hash dt { color: rgb(var(--fg-muted)); opacity: 1; }
-.hero-meta-cell dd { margin: 0; min-width: 0; }
-.hero-meta-hash {
-  display: block;
-  font-family: var(--font-mono);
-  font-size: 0.6875rem;
-  letter-spacing: calc(0.04em * var(--tracking-scale));
-  color: rgb(var(--fg-default));
-  word-break: break-all;
-  user-select: all;
-}
-.hero-meta-user {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.35rem;
-  font-family: var(--font-mono);
-  font-size: 0.75rem;
-  font-weight: 700;
-  color: rgb(var(--release-rose));
-  text-decoration: none;
-  transition: filter var(--dur-2) ease, transform var(--dur-3) ease;
-}
-.hero-meta-user:hover {
-  filter: brightness(1.15);
-  transform: translateY(-1px);
-}
-.hero-meta-user-icon {
-  font-size: 0.6875rem;
-  color: rgb(var(--release-rose));
-  opacity: 0.85;
-}
-.hero-meta-user--gone {
-  color: rgb(var(--fg-faint));
-  font-style: italic;
-  cursor: help;
-}
-.hero-meta-user--gone .hero-meta-user-icon { color: rgb(var(--fg-faint)); }
+/**
+ * Les actions secondaires ont leur propre carte dans la colonne épinglée.
+ * Sans aucune — visiteur non connecté — la carte ne se rend pas.
+ */
+/**
+ * Le compteur du membre, pour la bande « ce que ça vous coûte ». La session
+ * porte déjà `uploaded`/`downloaded` — c'est ce que l'en-tête affiche — mais
+ * rien ne garantit leur type d'un transport à l'autre, d'où `Number()`.
+ */
+const viewerStats = computed(() => {
+  const u = user.value as { uploaded?: unknown; downloaded?: unknown } | null;
+  if (!u) return null;
+  return { uploaded: Number(u.uploaded ?? 0) || 0, downloaded: Number(u.downloaded ?? 0) || 0 };
+});
 
-/* ── Embedded metadata card spacing ───────────────────────────── */
-.release-metadata { margin-bottom: 2rem; }
+/**
+ * Le titre du héros quand aucun fournisseur n'a répondu.
+ *
+ * Le nom de release tel quel — « Radiohead - In Rainbows (2007) [FLAC 24-96
+ * Vinyl] » — faisait un titre d'affiche de quatre lignes sur téléphone, puis se
+ * répétait mot pour mot dans la bande d'identité. L'analyseur en tire un titre
+ * (« Radiohead - In Rainbows », 2007) ; on ne s'en sert que s'il a RECONNU
+ * quelque chose (une nature ou une année), sinon il rend le nom presque intact
+ * en perdant ses points — « Baldur's Gate 3 v4 1 1 4667176 » — et le nom brut
+ * dans la bande vaut mieux qu'un titre abîmé. Sans titre, la bande porte le
+ * `<h1>` : la page n'en est jamais privée.
+ */
+const heroTitle = computed(() => {
+  const tor = torrent.value;
+  if (!tor) return null;
+  const p = parseReleaseName(tor.name);
+  const title = p.title?.trim();
+  if (!title || title === tor.name) return null;
+  return p.kind || p.year ? title : null;
+});
 
-/* ╔═══════════════════════════════════════════════════════════════╗
-   ║  SECTIONS                                                       ║
-   ╚═══════════════════════════════════════════════════════════════╝ */
-.section {
-  margin-bottom: 2.25rem;
-  animation: sectionRise calc(0.6s * var(--motion-scale)) var(--ease-emphasis) both;
-}
-.section:nth-of-type(2) { animation-delay: calc(0.05s * var(--motion-scale)); }
-.section:nth-of-type(3) { animation-delay: calc(0.1s * var(--motion-scale)); }
-.section:nth-of-type(4) { animation-delay: var(--dur-2); }
-.section:nth-of-type(5) { animation-delay: var(--dur-4); }
-@keyframes sectionRise {
-  from { opacity: 0; transform: translateY(8px); }
-  to   { opacity: 1; transform: translateY(0); }
-}
+/**
+ * Une note de plus de 1 200 caractères se replie à ~26 rem avec un fondu et
+ * un bouton ; décidé sur la LONGUEUR au rendu serveur, pas sur la hauteur au
+ * montage — sinon la section se raccourcit après l'affichage et tout ce qui
+ * suit remonte. La case « tout afficher » la déplie aussi : c'est son rôle.
+ */
+const noteLong = computed(() => (torrent.value?.description?.length ?? 0) > 1200);
+const expandAll = useExpandAll();
+/**
+ * Une note longue se déplie par défaut, et le membre règle ce défaut : la
+ * replier la replie sur TOUTES les fiches, la redéplier les redéplie toutes.
+ * Un cookie plutôt que `localStorage`, parce que le rendu serveur le lit : la
+ * page arrive déjà dans l'état choisi, au lieu d'une note qui se referme
+ * après l'hydratation. Même durée et mêmes attributs que le thème.
+ */
+const noteFolded = useCookie<boolean>('trackarr-note-folded', {
+  default: () => false,
+  maxAge: 60 * 60 * 24 * 365,
+  sameSite: 'lax',
+  path: '/',
+  httpOnly: false,
+});
+const noteClamped = computed(() => noteLong.value && noteFolded.value && !expandAll.value);
 
-.section-head {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  margin-bottom: 1.1rem;
-  padding-bottom: 0.4rem;
-}
-.section-head-mark {
-  font-family: var(--font-display);
-  font-style: italic;
-  font-weight: 600;
-  font-size: 1.85rem;
-  line-height: 1;
-  color: rgb(var(--section-tint, var(--accent)));
-  transform: translateY(-2px);
-  flex-shrink: 0;
-  filter: drop-shadow(0 0 10px rgb(var(--section-tint, var(--accent)) / 0.35));
-}
-/* Per-section accent tint for the chapter mark + line. Each section
-   borrows a hue that fits its content: green for the live activity
-   metrics, amber for the technical NFO artefact, violet for the
-   cross-seed family, red for the admin swarm console. */
-.section--activity { --section-tint: var(--online); }
-.section--note     { --section-tint: var(--accent); }
-.section--nfo      { --section-tint: var(--warning); }
-.section--cross    { --section-tint: var(--release-purple); }
-.section--swarm    { --section-tint: var(--danger); }
-.section--buffs    { --section-tint: var(--accent-warm); }
-.section--activity .section-head-line,
-.section--nfo .section-head-line,
-.section--cross .section-head-line,
-.section--swarm .section-head-line,
-.section--buffs .section-head-line,
-.section--note .section-head-line {
-  background: linear-gradient(
-    90deg,
-    rgb(var(--section-tint) / 0.45),
-    transparent 75%
-  );
-}
-.section-head-title {
-  margin: 0;
-  font-family: var(--font-display);
-  font-style: italic;
-  font-weight: 500;
-  font-size: clamp(1.15rem, 2.2vw, 1.6rem);
-  letter-spacing: calc(-0.01em * var(--tracking-scale));
-  color: rgb(var(--fg-strong));
-}
-.section-head-count {
-  font-family: var(--font-mono);
-  font-size: 0.625rem;
-  font-weight: 800;
-  letter-spacing: calc(0.16em * var(--tracking-scale));
-  color: rgb(var(--fg-muted));
-  padding: 0.18rem 0.5rem;
-  border: 1px solid rgb(var(--line-default));
-  border-radius: var(--radius-pill);
-  font-variant-numeric: tabular-nums;
-  flex-shrink: 0;
-}
-.section-head-tag {
-  font-family: var(--font-mono);
-  font-size: 0.5625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.22em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-  padding: 0.18rem 0.45rem;
-  border: 1px solid rgb(var(--line-default));
-  background: rgb(var(--bg-elevated) / 0.55);
-  border-radius: var(--radius-sm);
-  cursor: help;
-  flex-shrink: 0;
-}
-.section-head-meta {
-  font-family: var(--font-mono);
-  font-size: 0.625rem;
-  font-weight: 600;
-  letter-spacing: calc(0.14em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-  font-variant-numeric: tabular-nums;
-}
-.section-head-line {
-  flex: 1 1 auto;
-  height: 1px;
-  background: linear-gradient(
-    90deg,
-    rgb(var(--line-default)),
-    transparent 75%
-  );
-  min-width: 1rem;
-}
-.section-head--toggle {
-  padding-bottom: 0;
-}
-/* Compact variant — used by the NFO row. Smaller mark, smaller
-   title, tighter margin: the NFO is a release-engineering artefact
-   that ships with most uploads, and rendering it at the full
-   editorial chapter scale gives it visual parity with the
-   description (which is more important to read). */
-.section--compact { margin-bottom: 1.5rem; }
-.section-head--compact { margin-bottom: 0.4rem; gap: 0.55rem; }
-.section-head--compact .section-head-mark {
-  font-size: 1.2rem;
-  transform: translateY(-1px);
-}
-.section-head--compact .section-head-title {
-  font-size: 0.95rem;
-  font-style: italic;
-  font-weight: 500;
-}
-.section-head--compact .section-head-meta {
-  font-size: 0.5625rem;
-  letter-spacing: calc(0.18em * var(--tracking-scale));
-}
-.section-head--compact .section-head-caret { font-size: 0.5625rem; }
-.section-head--compact .section-head-button {
-  padding: 0.15rem 0.05rem;
-}
-.section-head-button {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  flex: 1 1 auto;
-  background: transparent;
-  border: 0;
-  padding: 0.2rem 0.1rem;
-  cursor: pointer;
-  text-align: left;
-  color: inherit;
-  font: inherit;
-  transition: color var(--dur-2) ease;
-}
-.section-head-button:hover .section-head-title {
-  color: rgb(var(--accent));
-}
-.section-head-caret {
-  margin-left: auto;
-  font-size: 0.625rem;
-  color: rgb(var(--fg-muted));
-  transition: transform var(--dur-4) ease;
-  flex-shrink: 0;
-}
-.section-head-caret.is-expanded { transform: rotate(90deg); }
-.section-head-action {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.35rem;
-  padding: 0.4rem 0.7rem;
-  background: transparent;
-  border: 1px solid rgb(var(--line-default));
-  border-radius: var(--radius-sm);
-  font-family: var(--font-mono);
-  font-size: 0.625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.16em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-  cursor: pointer;
-  transition: color var(--dur-2), border-color var(--dur-2), background var(--dur-2);
-}
-.section-head-action:hover {
-  color: rgb(var(--fg-strong));
-  border-color: rgb(var(--fg-default) / 0.35);
-  background: rgb(var(--bg-elevated) / 0.4);
-}
+const hasActions = computed(
+  () =>
+    canFavorite.value ||
+    canAskReseed.value ||
+    canEdit.value ||
+    canReport.value ||
+    canDelete.value,
+);
 
-/* ╔═══════════════════════════════════════════════════════════════╗
-   ║  STATS CLUSTER — tinted pill cards                              ║
-   ║  Each metric carries its own semantic colour (online/warning/   ║
-   ║  info/violet), tinted lightly enough to keep the page dark but  ║
-   ║  vivid enough to read as separate "chips" rather than one neutr-║
-   ║  al strip.                                                      ║
-   ╚═══════════════════════════════════════════════════════════════╝ */
-.stats-cluster {
-  list-style: none;
-  margin: 0;
-  padding: 0;
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
-  gap: 0.65rem;
-}
-.stat {
-  position: relative;
-  display: flex;
-  align-items: center;
-  gap: 0.85rem;
-  padding: 0.85rem 1rem;
-  background:
-    linear-gradient(135deg, rgba(255, 255, 255, 0.04), transparent 60%),
-    linear-gradient(
-      rgb(var(--rail, var(--fg-muted)) / 0.16),
-      rgb(var(--rail, var(--fg-muted)) / 0.16)
-    ),
-    rgb(var(--bg-surface));
-  border: 1px solid rgb(var(--rail, var(--fg-muted)) / 0.55);
-  border-radius: var(--radius-lg);
-  box-shadow:
-    0 6px 16px -10px rgb(var(--shadow-color) / calc(0.55 * var(--shadow-strength))),
-    inset 0 0 0 1px rgba(255, 255, 255, 0.025);
-  transition:
-    background var(--dur-4) ease,
-    border-color var(--dur-4) ease,
-    transform var(--dur-slow) var(--ease-emphasis);
-  isolation: isolate;
-  overflow: hidden;
-}
-.stat::before {
-  /* Faint diagonal sheen so each chip feels like a soft-lit panel
-     rather than a flat colour swatch — same trick a glass UI uses. */
-  content: '';
-  position: absolute;
-  inset: 0;
-  background: linear-gradient(
-    135deg,
-    rgba(255, 255, 255, 0.04),
-    transparent 55%
+/**
+ * Le sommaire de la colonne épinglée.
+ *
+ * Calculé depuis ce que la page SAIT au rendu serveur, pour que le HTML servi
+ * et l'hydratation disent la même chose : la description et le NFO sont dans
+ * la charge, les pistes se déduisent du même analyseur que `TrackTables`
+ * emploie, les commentaires sont toujours là. Les versions dépendent d'une
+ * requête que la table fait elle-même : l'entrée est listée, puis retirée au
+ * montage si la section n'a rien rendu — voir `pruneToc`.
+ */
+const hasTracks = computed(() => {
+  const t = torrent.value;
+  if (!t) return false;
+  for (const raw of [t.nfo, t.description]) {
+    if (!raw) continue;
+    const sheet = parseMediaInfoText(raw);
+    // La MÊME condition que `TrackTables` : une fiche technique sans piste
+    // audio ni sous-titre ne rend rien, et l'entrée apparaissait au rendu
+    // serveur pour être retirée au montage.
+    if (sheet.audio.length || sheet.text.length) return true;
+  }
+  return false;
+});
+const tocEntries = computed(() => {
+  // `tor`, pas `t` : `t` est la fonction d'i18n, et l'ombrager ici rendait
+  // « This expression is not callable » cinq lignes plus bas.
+  const tor = torrent.value;
+  if (!tor) return [] as Array<{ id: string; label: string; count: number | null }>;
+  const out: Array<{ id: string; label: string; count: number | null }> = [];
+  out.push({ id: 'versions', label: t('torrents.detail.versions.title'), count: null });
+  if (tor.description) out.push({ id: 'note', label: t('torrents.detail.sections.note'), count: null });
+  if (hasTracks.value) out.push({ id: 'tracks', label: t('torrents.detail.tracks.title'), count: null });
+  if (tor.nfo) out.push({ id: 'nfo', label: t('torrents.detail.sections.nfo'), count: null });
+  out.push({
+    id: 'comments',
+    label: t('torrents.detail.comments.title'),
+    count: commentCount.value,
+  });
+  return out;
+});
+const tocHidden = ref<Set<string>>(new Set());
+const activeSection = ref<string>('versions');
+onMounted(() => {
+  // Ce qui n'a rien rendu sort du sommaire ; ce qui reste est suivi au
+  // défilement. Tout ceci est côté client : le sommaire n'existe qu'à partir
+  // de 1024 px, il n'a rien à annoncer au rendu serveur.
+  const hidden = new Set<string>();
+  const targets: HTMLElement[] = [];
+  for (const e of tocEntries.value) {
+    const el = document.getElementById(e.id);
+    if (!el || el.children.length === 0) hidden.add(e.id);
+    else targets.push(el);
+  }
+  tocHidden.value = hidden;
+  if (typeof IntersectionObserver === 'undefined' || !targets.length) return;
+  const io = new IntersectionObserver(
+    (entries) => {
+      const visible = entries
+        .filter((en) => en.isIntersecting)
+        .sort((a, b) => a.boundingClientRect.top - b.boundingClientRect.top)[0];
+      if (visible) activeSection.value = (visible.target as HTMLElement).id;
+    },
+    { rootMargin: '-80px 0px -55% 0px', threshold: 0 },
   );
-  pointer-events: none;
-  z-index: -1;
-}
-.stat:hover {
-  background:
-    linear-gradient(135deg, rgba(255, 255, 255, 0.06), transparent 60%),
-    linear-gradient(
-      rgb(var(--rail, var(--fg-muted)) / 0.24),
-      rgb(var(--rail, var(--fg-muted)) / 0.24)
-    ),
-    rgb(var(--bg-surface));
-  border-color: rgb(var(--rail, var(--fg-muted)) / 0.8);
-  transform: translateY(-1px);
-}
-.stat-icon {
-  font-size: 1.1rem;
-  color: rgb(var(--rail, var(--fg-muted)));
-  flex-shrink: 0;
-  filter: drop-shadow(0 0 8px rgb(var(--rail, var(--fg-muted)) / 0.45));
-}
-.stat-num {
-  font-family: var(--font-mono);
-  font-size: clamp(1.35rem, 2.4vw, 1.7rem);
-  font-weight: 800;
-  line-height: 1;
-  color: rgb(var(--rail, var(--fg-strong)));
-  letter-spacing: calc(-0.025em * var(--tracking-scale));
-  word-break: break-word;
-}
-.stat-label {
-  font-family: var(--font-mono);
-  font-size: 0.5625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.22em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-  margin-top: 0.2rem;
-}
-.stat-body {
-  display: flex;
-  flex-direction: column;
-  align-items: flex-start;
-  min-width: 0;
-}
-.stat-sub {
-  font-family: var(--font-mono);
-  font-size: 0.5313rem;
-  font-weight: 700;
-  letter-spacing: calc(0.16em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--release-purple));
-  padding: 0.08rem 0.35rem;
-  border: 1px solid rgb(var(--release-purple) / 0.45);
-  background: rgb(var(--release-purple) / 0.12);
-  border-radius: var(--radius-pill);
-  margin-top: 0.3rem;
-  font-variant-numeric: tabular-nums;
-  align-self: flex-start;
-}
-
-/* One hue per metric — each chip carries its own semantic colour so
-   the row reads as five distinct readings, not five almost-identical
-   panels. Stats share the convention green=seeders / red=leechers /
-   cyan=completed with most tracker UIs, which is intentional:
-   breaking it would cost more in recognition than it would buy us in
-   palette dispersion. */
-.stat--seeders   { --rail: var(--online); }
-.stat--leechers  { --rail: var(--danger); }
-.stat--completed { --rail: var(--info); }
-.stat--size      { --rail: var(--release-teal); }
-.stat--volume    { --rail: var(--release-purple); }
+  for (const el of targets) io.observe(el);
+  onBeforeUnmount(() => io.disconnect());
+  // La barre du sommaire suit l'entrée active ; mesurée après le rendu.
+  watch([activeSection, tocHidden], () => nextTick(placeTocBar), { immediate: true });
+});
+</script>
 
-/* Zero-value variant: keep the rail tint on the chip frame so the
-   reader still parses "seeders, currently 0" rather than five
-   identical grey panels, but mute only the icon glow + the number
-   so the "no activity" signal still lands. */
-.stat.is-zero .stat-icon {
-  opacity: 0.55;
-  filter: none;
-}
-.stat.is-zero .stat-num {
-  color: rgb(var(--fg-faint));
-  font-weight: 700;
-}
+<template>
+  <div
+    v-if="torrent"
+    class="release-page"
+    :class="{ 'release-page--tinted': workTint }"
+    :style="workTint ? { '--work-tint': workTint } : undefined"
+  >
+    <!-- Le filtre adulte est une PAGE parallèle, pas une variante : un membre
+         qui a désactivé ce contenu ne doit rien apprendre du torrent. -->
+    <TorrentDetailAdultGate
+      v-if="gated"
+      :hash="hash"
+      :category-name="gatedCategoryName"
+    />
 
-/* ╔═══════════════════════════════════════════════════════════════╗
-   ║  NOTE — uploader description editorial block                   ║
-   ╚═══════════════════════════════════════════════════════════════╝ */
-.note-block {
-  position: relative;
-  /* Top padding clears the decorative quotation watermark so the first
-     line of description text never slides under the glyph. */
-  padding: 3rem 1.6rem 1.3rem 2.4rem;
-  background:
-    linear-gradient(
-      135deg,
-      rgb(var(--accent) / 0.04),
-      transparent 60%
-    ),
-    rgb(var(--bg-elevated));
-  border: 1px solid rgb(var(--line-strong));
-  border-left: 3px solid rgb(var(--accent));
-  border-radius: 0 var(--radius-md) var(--radius-md) 0;
-  font-size: 0.875rem;
-  line-height: 1.65;
-  color: rgb(var(--fg-default));
-  box-shadow: 0 6px 16px -10px rgb(var(--shadow-color) / calc(0.55 * var(--shadow-strength)));
-}
-.note-block::before {
-  content: '“';
-  position: absolute;
-  top: 0.2rem;
-  left: 0.85rem;
-  font-family: var(--font-display);
-  font-size: 2.6rem;
-  line-height: 1;
-  font-weight: 600;
-  color: rgb(var(--accent) / 0.32);
-  pointer-events: none;
-}
+    <template v-else>
+      <!-- Les deux commandes de la PAGE, par opposition à celles du torrent,
+           qui vivent dans la colonne de droite. -->
+      <div class="page-bar">
+        <NuxtLink to="/torrents" class="back-link">
+          <Icon name="ph:arrow-left" /> {{ $t('torrents.detail.back') }}
+        </NuxtLink>
+        <TorrentDetailExpandAllToggle />
+      </div>
 
-/* ╔═══════════════════════════════════════════════════════════════╗
-   ║  CROSS-SEEDS LIST                                              ║
-   ╚═══════════════════════════════════════════════════════════════╝ */
-.cross-note {
-  display: flex;
-  align-items: flex-start;
-  gap: 0.4rem;
-  margin: 0 0 0.7rem;
-  font-size: 0.78rem;
-  line-height: 1.5;
-  color: rgb(var(--fg-muted));
-}
-.cross-note-icon {
-  flex-shrink: 0;
-  margin-top: 0.12rem;
-  color: rgb(var(--fg-faint));
-}
-.cross-list {
-  list-style: none;
-  margin: 0;
-  padding: 0;
-  display: flex;
-  flex-direction: column;
-  gap: 0.45rem;
-}
-.cross-item { display: block; }
-.cross-link {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  padding: 0.85rem 1rem;
-  background:
-    linear-gradient(
-      rgb(var(--release-purple) / 0.06),
-      rgb(var(--release-purple) / 0.06)
-    ),
-    rgb(var(--bg-elevated));
-  border: 1px solid rgb(var(--line-strong));
-  border-radius: var(--radius-md);
-  text-decoration: none;
-  color: rgb(var(--fg-default));
-  box-shadow: 0 4px 12px -8px rgb(var(--shadow-color) / calc(0.5 * var(--shadow-strength)));
-  transition:
-    background var(--dur-3) ease,
-    border-color var(--dur-3) ease,
-    transform var(--dur-4) var(--ease-emphasis);
-}
-.cross-link:hover {
-  background:
-    linear-gradient(
-      rgb(var(--release-purple) / 0.14),
-      rgb(var(--release-purple) / 0.14)
-    ),
-    rgb(var(--bg-elevated));
-  border-color: rgb(var(--release-purple) / 0.6);
-  transform: translateX(2px);
-}
-.cross-icon {
-  flex-shrink: 0;
-  color: rgb(var(--fg-muted));
-  font-size: 1rem;
-}
-.cross-name {
-  flex: 1 1 auto;
-  font-family: var(--font-mono);
-  font-size: 0.75rem;
-  font-weight: 600;
-  color: rgb(var(--fg-strong));
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-  min-width: 0;
-}
-.cross-link:hover .cross-name { color: rgb(var(--accent)); }
-.cross-meta {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.35rem;
-  flex-shrink: 0;
-  font-family: var(--font-mono);
-  font-size: 0.625rem;
-  letter-spacing: calc(0.12em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-  font-variant-numeric: tabular-nums;
-}
-.cross-meta-sep { opacity: 0.45; }
-.cross-meta-cat { color: rgb(var(--fg-default)); font-weight: 700; }
-.cross-arrow {
-  flex-shrink: 0;
-  color: rgb(var(--fg-faint));
-  font-size: 0.85rem;
-  transition: transform var(--dur-3), color var(--dur-3);
-}
-.cross-link:hover .cross-arrow {
-  color: rgb(var(--accent));
-  transform: translateX(2px);
-}
-.cross-badge {
-  font-size: 0.68rem;
-  font-weight: 600;
-  padding: 0.05rem 0.4rem;
-  border-radius: var(--radius-pill);
-  border: 1px solid;
-  white-space: nowrap;
-}
-.cross-badge--verified {
-  color: rgb(var(--online));  /* jeton sémantique : cette teinte était figée sur le thème sombre */
-  background: rgba(34, 197, 94, 0.08);
-  border-color: rgba(34, 197, 94, 0.3);
-}
-.cross-badge--hint {
-  color: rgb(var(--fg-subtle));
-  background: rgb(var(--bg-inset));
-  border-color: rgb(var(--line-default));
-}
-.cross-meta-seed { color: #4ade80; font-family: var(--font-mono); font-size: 0.72rem; }
-.cross-mesh {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.3rem;
-  margin-left: 0.5rem;
-  padding: 0.05rem 0.5rem;
-  border-radius: var(--radius-pill);
-  font-weight: 600;
-  color: rgb(var(--online));  /* jeton sémantique : cette teinte était figée sur le thème sombre */
-  background: rgba(34, 197, 94, 0.08);
-  border: 1px solid rgba(34, 197, 94, 0.25);
-}
-@media (max-width: 720px) {
-  .cross-link {
-    flex-wrap: wrap;
-    align-items: flex-start;
-  }
-  .cross-name { white-space: normal; }
-  .cross-arrow { display: none; }
-}
+      <!-- 1 · Qu'est-ce que c'est, et quelle release. Le bandeau, l'affiche,
+           le titre, puis la bande d'identité avec les pastilles de qualité :
+           des faits sur cette release, donc à côté de son nom. -->
+      <TorrentDetailIdentityCard
+        :release-name="torrent.name"
+        :media="metadata"
+        :media-pending="metadataPending"
+        :fallback-title="heroTitle"
+        title-level="h1"
+        :info-hash="torrent.infoHash"
+        :imdb-id="torrent.imdbId"
+        :tmdb-link="tmdbLink"
+        :tvdb-id="torrent.tvdbId"
+        :igdb-id="torrent.igdbId"
+        :openlibrary-id="torrent.openlibraryId"
+        :crumbs="heroCrumbs"
+        :can-report="canReport"
+        @report-metadata="reportMetadata"
+        @tint="onTint"
+      >
+        <template #chips>
+          <TorrentDetailQualityChips :name="torrent.name" :tags="torrent.tags" />
+        </template>
+        <!-- Qui l'a publiée : au bout de la ligne des pastilles. -->
+        <template #provenance>
+          <TorrentDetailProvenanceRow
+            bare
+            :release-name="torrent.name"
+            :uploader="torrent.uploader"
+            :uploader-anonymous="torrent.uploaderAnonymous"
+            :tags="torrent.tags"
+          />
+        </template>
+      </TorrentDetailIdentityCard>
 
-/* ╔═══════════════════════════════════════════════════════════════╗
-   ║  SWARM TABLE                                                    ║
-   ╚═══════════════════════════════════════════════════════════════╝ */
-.swarm-frame {
-  border: 1px solid rgb(var(--line-strong));
-  border-radius: var(--radius-lg);
-  overflow-x: auto;
-  background: rgb(var(--bg-elevated));
-  box-shadow: 0 6px 18px -10px rgb(var(--shadow-color) / calc(0.55 * var(--shadow-strength)));
-}
-.swarm-table {
-  width: 100%;
-  border-collapse: collapse;
-  font-family: var(--font-mono);
-  font-size: 0.6875rem;
-}
-.swarm-table thead th {
-  text-align: left;
-  padding: 0.65rem 1rem;
-  font-size: 0.5938rem;
-  font-weight: 700;
-  letter-spacing: calc(0.22em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-  background: rgb(var(--bg-base) / 0.4);
-  border-bottom: 1px solid rgb(var(--line-default));
-}
-.swarm-table tbody td {
-  padding: 0.6rem 1rem;
-  border-bottom: 1px solid rgb(var(--line-default) / 0.55);
-  color: rgb(var(--fg-default));
-  vertical-align: middle;
-}
-.swarm-table tbody tr:last-child td { border-bottom: 0; }
-.swarm-table tbody tr:hover td { background: rgb(var(--bg-elevated) / 0.45); }
-.swarm-endpoint { color: rgb(var(--fg-muted)); }
-.swarm-port { color: rgb(var(--fg-faint)); }
-.swarm-num {
-  color: rgb(var(--fg-default));
-  font-variant-numeric: tabular-nums;
-  font-size: 0.6563rem;
-}
-.swarm-type {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.3rem;
-  padding: 0.18rem 0.5rem;
-  border: 1px solid;
-  border-radius: var(--radius-xs);
-  font-size: 0.5625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.18em * var(--tracking-scale));
-  text-transform: uppercase;
-}
-.swarm-type--seeder {
-  color: rgb(var(--online));
-  border-color: rgb(var(--online) / 0.4);
-  background: rgb(var(--online) / 0.08);
-}
-.swarm-type--leecher {
-  color: rgb(var(--warning));
-  border-color: rgb(var(--warning) / 0.4);
-  background: rgb(var(--warning) / 0.08);
-}
-.swarm-empty {
-  text-align: center;
-  padding: 2.5rem 1rem;
-  font-size: 0.625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.22em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-}
+      <!-- En attente d'action : le panneau passe AU-DESSUS, sinon l'uploadeur
+           découvre ce qu'on lui demande après avoir défilé toute la page. -->
+      <TorrentModerationPanel
+        v-if="moderationOnTop"
+        :hash="hash"
+        :status="torrent.moderationStatus"
+        :uploader-id="torrent.uploaderId"
+        @status-change="() => refreshTorrent()"
+      />
 
-/* ── Tabular numerals utility (matches reports.vue) ───────────── */
-.tabular-nums { font-variant-numeric: tabular-nums; }
+      <!-- Deux colonnes dès 1024 px. La colonne de DÉCISION est première dans
+           le document : sur une colonne (téléphone) elle suit donc le bandeau,
+           là où était la carte de décision ; sur deux, la grille la place à
+           droite et l'épingle. Et le bouton de téléchargement reste tôt dans
+           l'ordre de tabulation, comme avant. -->
+      <div class="release-body">
+        <aside class="release-aside" :aria-label="$t('torrents.detail.dock.label')">
+          <!-- 2 · Puis-je la prendre, et devrais-je. -->
+          <TorrentDetailDecisionCard
+            :size="torrent.size"
+            :stats="torrent.stats ?? null"
+            :cross-seed-stats="crossSeedStats"
+            :buff="buff"
+            :buff-pair="buffPair"
+            :buff-ends-in="buffEndsIn"
+            :obligation="obligation"
+            :viewer-stats="viewerStats"
+            :hash="torrent.infoHash"
+            :peers="torrent.peers ?? null"
+          >
+            <template #cta>
+              <TorrentDetailDownloadCta
+                :hash="torrent.infoHash"
+                :size="torrent.size"
+                :seeders="torrent.stats?.seeders ?? null"
+                :freeleech="buff?.kind === 'freeleech'"
+                aria-keyshortcuts="d"
+                @taken="onTaken"
+              />
+            </template>
+          </TorrentDetailDecisionCard>
+
+          <!-- Les actions secondaires, dans leur propre carte : le rouge de
+               « Supprimer » ne voisine plus le bouton principal. -->
+          <section v-if="hasActions" class="card acts" aria-labelledby="acts-title">
+            <h2 id="acts-title" class="aside-title">{{ $t('torrents.detail.aside.actions') }}</h2>
+            <div class="acts-list">
+              <button
+                v-if="canFavorite"
+                type="button"
+                class="btn btn-secondary btn-sm fav-toggle"
+                :disabled="favoriteBusy"
+                :aria-pressed="favorited"
+                :title="
+                  $t(
+                    favorited
+                      ? 'torrents.detail.favoriteRemove'
+                      : 'torrents.detail.favoriteAdd',
+                  )
+                "
+                aria-keyshortcuts="f"
+                @click="toggleFavorite"
+              >
+                <Icon :name="favorited ? 'ph:star-fill' : 'ph:star'" />
+                <!-- Libellé CONSTANT, état porté par `aria-pressed` : c'est le
+                     motif d'un bouton bascule. L'action va sur `title`. -->
+                {{ $t('torrents.detail.favorite') }}
+              </button>
+              <!-- Proposer une relance n'a de sens qu'à zéro seeder. -->
+              <button
+                v-if="canAskReseed && !reseedResult"
+                type="button"
+                class="btn btn-secondary btn-sm"
+                :disabled="reseedBusy"
+                @click="askReseed"
+              >
+                <Icon name="ph:megaphone" /> {{ $t('torrents.detail.reseed.ask') }}
+              </button>
+              <NuxtLink
+                v-if="canEdit"
+                :to="`/torrents/${torrent?.infoHash}/edit`"
+                class="btn btn-secondary btn-sm"
+              >
+                <Icon name="ph:pencil-simple" /> {{ $t('common.edit') }}
+              </NuxtLink>
+              <button
+                v-if="canReport"
+                type="button"
+                class="btn btn-ghost btn-sm"
+                @click="reportOpen = true"
+              >
+                <Icon name="ph:flag" /> {{ $t('torrents.detail.report') }}
+              </button>
+              <button
+                v-if="canDelete"
+                type="button"
+                class="btn btn-danger btn-sm"
+                @click="confirmDelete"
+              >
+                <Icon name="ph:trash" /> {{ $t('common.delete') }}
+              </button>
+            </div>
+            <!-- Un raccourci que personne ne connaît est un raccourci que
+                 personne n'emploie : la touche est écrite là où sont les
+                 actions. -->
+            <p class="acts-keys">
+              <span class="acts-keys-label">{{ $t('torrents.detail.aside.shortcuts') }}</span>
+              <kbd>D</kbd> {{ $t('torrents.detail.aside.shortcutDownload') }}
+              <template v-if="canFavorite">
+                <span class="acts-keys-sep" aria-hidden="true">·</span>
+                <kbd>F</kbd> {{ $t('torrents.detail.aside.shortcutFavorite') }}
+              </template>
+            </p>
+          </section>
+
+          <!-- Le sommaire : une page de 3 000 px devient navigable. Bureau
+               seulement — sur une colonne il serait en bas de tout. -->
+          <nav
+            v-if="tocEntries.length > 1"
+            class="card toc"
+            :aria-label="$t('torrents.detail.aside.onThisPage')"
+          >
+            <h2 class="aside-title">{{ $t('torrents.detail.aside.onThisPage') }}</h2>
+            <ul class="toc-list">
+              <li v-if="tocBar" class="toc-bar-host" aria-hidden="true"><span class="toc-bar" :style="tocBar" /></li>
+              <li v-for="e in tocEntries" :key="e.id" :hidden="tocHidden.has(e.id)">
+                <a
+                  :ref="(el) => setTocLink(e.id, el)"
+                  class="toc-link"
+                  :href="`#${e.id}`"
+                  :aria-current="activeSection === e.id ? 'true' : undefined"
+                >
+                  <span>{{ e.label }}</span>
+                  <span v-if="e.count !== null" class="toc-n">{{ e.count }}</span>
+                </a>
+              </li>
+            </ul>
+          </nav>
+        </aside>
+
+        <div class="release-main">
+          <!-- 3 · Laquelle de ces versions je prends. La question centrale,
+               donc la première de la colonne de lecture. -->
+          <div id="versions" class="rsec">
+            <TorrentDetailVersionsTable
+              :group-key="groupKey"
+              :current-info-hash="torrent.infoHash"
+              :season="torrent.season ?? null"
+              :episode="torrent.episode ?? null"
+            />
+          </div>
 
-/* Media-id badges. Each one carries a subtle tint of the database's
-   brand colour so the user can scan the trio at a glance: yellow for
-   IMDb, teal for TMDb, blue for TVDB. The tint is applied with low
-   alpha so the chip still reads on the light theme. */
-.media-id-badge {
-  @apply inline-flex items-center gap-1.5 text-[10px] font-bold uppercase
-         tracking-wider px-2 py-1 rounded-sm border transition-colors
-         text-text-primary;
-}
-.media-id-badge:hover {
-  filter: brightness(1.15);
-}
-.media-id-badge .media-id-badge-tag {
-  @apply font-extrabold;
-}
-.media-id-badge .media-id-badge-id {
-  @apply font-mono normal-case tracking-tight text-text-secondary;
-}
+          <div v-if="torrent.description" id="note" class="rsec">
+            <section class="section">
+              <SectionHead :title="$t('torrents.detail.sections.note')" icon="ph:note" />
+              <!-- Pas de `ClientOnly` : `DescriptionRender` assainit sous Node
+                   comme dans le navigateur — vérifié. -->
+              <div ref="noteBody" class="note-body" :class="{ 'note-body--clamped': noteClamped }" :id="noteLong ? 'note-body' : undefined">
+                <DescriptionRender :source="torrent.description" :heading-offset="2" />
+              </div>
+              <button
+                v-if="noteLong && !expandAll"
+                type="button"
+                class="btn btn-secondary btn-sm note-more"
+                :aria-expanded="!noteFolded"
+                aria-controls="note-body"
+                @click="toggleNote"
+              >
+                <Icon :name="noteFolded ? 'ph:caret-down-bold' : 'ph:caret-up-bold'" aria-hidden="true" />
+                {{ $t(noteFolded ? 'torrents.detail.sections.noteExpand' : 'torrents.detail.sections.noteCollapse') }}
+              </button>
+            </section>
+          </div>
 
-.media-id-badge--imdb {
-  background: rgba(245, 197, 24, 0.12);
-  border-color: rgba(245, 197, 24, 0.45);
-}
-  /* La teinte reste sur le fond et la bordure — donc l'identité média
-     (IMDb, TMDb) et la distinction de catégorie survivent — mais le LIBELLÉ
-     passe sur un jeton de premier plan. Une couleur de marque n'a pas de raison
-     d'être lisible sur les deux thèmes : `#f5c518` sur blanc mesure 1,50:1.
-     C'est exactement ce que `tagBadgeStyle()` fait déjà pour les tags, où la
-     couleur est choisie par un opérateur et où le texte reste donc toujours
-     lisible. */
-.media-id-badge--imdb .media-id-badge-tag {
-  color: rgb(var(--fg-default));
-}
-.media-id-badge--tmdb {
-  background: rgba(1, 180, 228, 0.12);
-  border-color: rgba(1, 180, 228, 0.45);
-}
-.media-id-badge--tmdb .media-id-badge-tag {
-  color: rgb(var(--fg-default));
-}
-.media-id-badge--tvdb {
-  background: rgba(108, 209, 97, 0.12);
-  border-color: rgba(108, 209, 97, 0.45);
-}
-.media-id-badge--tvdb .media-id-badge-tag {
-  color: rgb(var(--online));  /* jeton sémantique : cette teinte était figée sur le thème sombre */
-}
+          <!-- Les pistes avant le NFO : les faits compacts avant le bloc brut
+               dont ils sont extraits. -->
+          <div id="tracks" class="rsec">
+            <TorrentDetailTrackTables :nfo="torrent.nfo" :description="torrent.description" />
+          </div>
+          <div id="nfo" class="rsec">
+            <TorrentDetailNfoPanel :nfo="torrent.nfo" />
+          </div>
 
-/* Description typography lives in <DescriptionRender> now — the
-   `.description-content :deep(...)` block that used to live here
-   was migrated wholesale into that component so every surface
-   renders descriptions through one shared pipeline. */
+          <!-- 4 · Qu'en disent les autres. -->
+          <div id="comments" class="rsec">
+            <TorrentDetailTorrentComments
+              :hash="torrent.infoHash"
+              :comments="comments"
+              :total="commentCount"
+              :uploader-id="torrent.uploaderId ?? null"
+              @posted="() => refreshTorrent()"
+            />
+          </div>
 
-.nfo-frame {
-  position: relative;
-  background: rgb(var(--bg-inset, var(--bg-base)));
-  border: 1px solid rgb(var(--line-strong));
-  border-radius: var(--radius-lg);
-  padding: 1.05rem 1.1rem;
-  overflow: auto;
-  max-height: 70vh;
-  box-shadow: 0 6px 18px -10px rgb(var(--shadow-color) / calc(0.55 * var(--shadow-strength)));
-  /* Faint scanline pattern — vintage terminal flavour without going
-     overboard. Almost imperceptible on dark themes, vanishes on light. */
-  background-image: repeating-linear-gradient(
-    180deg,
-    transparent 0,
-    transparent 2px,
-    rgba(255, 255, 255, 0.014) 2px,
-    rgba(255, 255, 255, 0.014) 3px
-  );
-  animation: nfoOpen calc(0.35s * var(--motion-scale)) var(--ease-emphasis) both;
-}
-@keyframes nfoOpen {
-  from { opacity: 0; transform: translateY(-4px); }
-  to   { opacity: 1; transform: translateY(0); }
-}
+          <!-- 5 · Le reste. -->
+          <TorrentDetailRelatedReleases
+            v-if="crossSeeds?.items?.length"
+            variant="cross"
+            :items="crossSeeds.items"
+          />
+          <TorrentDetailRelatedReleases
+            v-if="supersessions?.supersedes?.length"
+            variant="supersedes"
+            :items="supersessions.supersedes"
+          />
+          <TorrentDetailRelatedReleases
+            v-if="federationEnabled && federatedCrossSeeds?.items?.length"
+            variant="federated"
+            :items="federatedCrossSeeds.items"
+            :mesh-seeders="federatedCrossSeeds.availability?.seeders ?? null"
+          />
 
-.nfo-body {
-  font-family: var(--font-mono);
-  font-size: 0.75rem;
-  line-height: 1.35;
-  color: rgb(var(--fg-default));
-  white-space: pre;
-  margin: 0;
-  tab-size: 4;
-  /* NFO ASCII art is visually centered when read in a fixed-width
-     terminal — keeping the natural width prevents reflow. */
-  width: max-content;
-  min-width: 100%;
-}
+          <!-- Regroupé par AUDIENCE et non par fonctionnalité. -->
+          <TorrentDetailOperatorArea
+            v-if="isStaff || canEdit"
+            :hash="hash"
+            :torrent="torrent"
+            :supersessions="supersessions"
+            :is-staff="isStaff"
+            :is-admin="!!user?.isAdmin"
+            :can-edit="canEdit"
+            :federation-enabled="federationEnabled"
+            @changed="() => { refreshTorrent(); refreshSupersessions(); }"
+          />
+
+          <TorrentModerationPanel
+            v-if="!moderationOnTop"
+            :hash="hash"
+            :status="torrent.moderationStatus"
+            :uploader-id="torrent.uploaderId"
+            @status-change="() => refreshTorrent()"
+          />
+        </div>
+      </div>
+
+      <!-- Le dock : sous 1024 px la colonne n'est plus épinglée et le bouton
+           principal défile ; le dock reprend le geste tant qu'il est hors
+           écran. Au-dessus, il est masqué par sa propre feuille. -->
+      <TorrentDetailStickyDock
+        :hash="torrent.infoHash"
+        :size="torrent.size"
+        :stats="torrent.stats ?? null"
+        :obligation="obligation"
+        :freeleech="buff?.kind === 'freeleech'"
+        @taken="onTaken"
+      />
+
+      <ReportModal
+        :is-open="reportOpen"
+        target-type="torrent"
+        :target-id="torrent.id"
+        :target-label="torrent.name"
+        :preset-reason="reportPreset"
+        @close="closeReport"
+        @submitted="closeReport"
+      />
+    </template>
+  </div>
+</template>
 
-/* ─── Adult-content gate ────────────────────────────────────────────
-   The "you opted out, so we redacted this page" treatment. Built on
-   the same operator-console primitives used elsewhere in the app
-   (mono eyebrows, hatched warning band, sharp danger borders) so it
-   reads as a deliberate filter rather than an error. */
-.adult-gate {
+<style scoped>
+.release-page {
+  /* L'échelle des libellés, déclarée ici : les composants la lisent, et une
+     valeur unique vaut mieux que douze recopies. */
+  --label-sm: 0.5625rem;
+  --label-md: 0.625rem;
+  --label-lg: 0.6875rem;
+  --label-weight: 700;
+  --label-tracking: calc(0.08em * var(--tracking-scale));
+  --label-tracking-wide: calc(0.16em * var(--tracking-scale));
+  max-width: var(--container-max);
+  margin: 0 auto;
+  /* Le bas : la hauteur du dock, qui est `sticky` donc en flux, et ne recouvre
+     rien au repos. */
+  padding: 1.25rem var(--container-pad) 4.5rem;
   display: flex;
   flex-direction: column;
-  gap: 1.5rem;
-  max-width: 720px;
-  margin: 1rem auto 4rem;
-  padding: 0 0.25rem;
-}
-.adult-gate__back {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.5rem;
-  font-family: var(--font-mono);
-  font-size: 0.625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.18em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-  transition: color var(--dur-2);
-  width: max-content;
-}
-.adult-gate__back:hover {
-  color: rgb(var(--fg-strong));
-}
-.adult-gate__panel {
+  gap: 1.25rem;
+  /* Le repère de la barre de commandes, posée par-dessus le bandeau. */
   position: relative;
-  border: 1px solid rgb(var(--line-default));
-  border-left: 3px solid rgb(var(--danger));
-  background: rgb(var(--bg-surface));
-  /* Subtle danger hatching tints the whole document so it reads as
-     "warning surface" without overwhelming the actual content. */
-  background-image: repeating-linear-gradient(
-    -45deg,
-    transparent,
-    transparent 16px,
-    rgba(229, 62, 62, 0.03) 16px,
-    rgba(229, 62, 62, 0.03) 18px
-  );
-  border-radius: var(--radius-lg);
-  overflow: hidden;
-  animation: gate-rise calc(0.45s * var(--motion-scale)) var(--ease-standard) both;
-}
-@keyframes gate-rise {
-  from {
-    opacity: 0;
-    transform: translateY(8px);
-  }
-  to {
-    opacity: 1;
-    transform: translateY(0);
-  }
 }
 
-.adult-gate__hatch {
+/* La barre de commandes FLOTTE sur le haut du bandeau au lieu d'occuper une
+   rangée au-dessus de lui : une rangée laissait 53 px de fond nu entre
+   l'en-tête et le décor, et le décor remontait quand même sous la moitié de
+   la barre. Hors flux, elle ne pousse rien ; le bandeau touche l'en-tête.
+   Elle reste PREMIÈRE dans le document — le lien de retour garde sa place en
+   tête de l'ordre de tabulation. `wrap` : le libellé de la case est traduit. */
+.page-bar {
+  position: absolute;
+  z-index: 2;
+  top: 0.75rem;
+  left: var(--container-pad);
+  right: var(--container-pad);
   display: flex;
+  flex-wrap: wrap;
   align-items: center;
   justify-content: space-between;
-  gap: 1rem;
-  padding: 0.7rem 1.1rem;
-  border-bottom: 1px solid rgb(var(--line-default));
-  background: repeating-linear-gradient(
-    -45deg,
-    rgba(229, 62, 62, 0.18),
-    rgba(229, 62, 62, 0.18) 14px,
-    rgba(229, 62, 62, 0.06) 14px,
-    rgba(229, 62, 62, 0.06) 28px
-  );
-  font-family: var(--font-mono);
-  font-size: 0.6563rem;
-  font-weight: 800;
-  letter-spacing: calc(0.22em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-strong));
+  gap: 0.5rem 1rem;
+  pointer-events: none;
+}
+.page-bar > * {
+  pointer-events: auto;
 }
-.adult-gate__hatch-label {
+/* Sur un décor, un lien nu n'a pas de contraste garanti — le ciel de Frieren
+   est blanc. La même pilule que la case « tout afficher » à sa droite : les
+   deux commandes se lisent comme une seule barre, sur n'importe quel pixel. */
+.back-link {
+  min-height: 2rem;
   display: inline-flex;
   align-items: center;
-  gap: 0.55rem;
-  color: rgb(var(--danger));
-}
-.adult-gate__hatch-route {
+  gap: 0.4rem;
+  padding: 0 0.7rem 0 0.55rem;
+  font-size: 0.8125rem;
   font-weight: 600;
-  letter-spacing: calc(0.06em * var(--tracking-scale));
-  text-transform: lowercase;
-  color: rgb(var(--fg-muted));
+  color: rgb(var(--fg-default));
+  background: rgb(var(--bg-elevated) / 0.82);
+  backdrop-filter: blur(8px);
+  border: 1px solid rgb(var(--line-default));
+  border-radius: var(--radius-pill);
+  transition:
+    color var(--dur-1) var(--ease-standard),
+    background-color var(--dur-2) ease;
 }
-.adult-gate__hash {
+.back-link:hover {
   color: rgb(var(--fg-strong));
-  background: rgb(var(--fg-strong));
-  /* The middle of the hash is rendered as an opaque bar by giving the
-     foreground the same colour as the background. The text is still
-     in the DOM (so screen readers ignore it via aria-hidden on the
-     wrapping span only when needed) but visually censored. */
+  background: rgb(var(--bg-hover));
 }
 
-.adult-gate__body {
-  position: relative;
-  padding: 2rem 1.6rem 1.5rem;
-  display: flex;
-  flex-direction: column;
-  gap: 1.1rem;
+/* ── Deux colonnes ────────────────────────────────────────────────────────
+ *
+ * La colonne de LECTURE (versions, note, pistes, NFO, commentaires) et la
+ * colonne de DÉCISION (télécharger, provenance, actions, sommaire). Sur une
+ * seule colonne, l'ordre du document fait foi : la décision d'abord, comme
+ * la carte de décision l'était avant. À partir de 1024 px la grille place la
+ * décision à droite et l'épingle sous l'en-tête.
+ */
+.release-body {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  gap: 1.25rem 1.75rem;
 }
-.adult-gate__eyebrow {
-  margin: 0;
-  font-family: var(--font-mono);
-  font-size: 0.625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.22em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-muted));
+.release-main,
+.release-aside {
+  display: grid;
+  /* `minmax(0, 1fr)` et non la piste implicite `auto` : `auto` se dimensionne
+     sur le contenu le plus large, et un bandeau de modération dont le texte
+     tient sur une ligne de 885 px imposait 1 025 px à une colonne de 580 —
+     mesuré à 1024 px de fenêtre, 41 px de défilement horizontal. La piste
+     bornée force le texte à se replier, ce qu'il sait faire. */
+  grid-template-columns: minmax(0, 1fr);
+  gap: 1.25rem;
+  min-width: 0;
+  align-content: start;
 }
-.adult-gate__title {
-  margin: 0;
-  display: flex;
-  flex-wrap: wrap;
-  align-items: center;
-  gap: 0.6rem;
-  font-size: clamp(2rem, 6vw, 3.4rem);
-  font-weight: 900;
-  letter-spacing: calc(-0.025em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-strong));
-  line-height: 1;
+.release-aside {
+  gap: 1rem;
+}
+@media (min-width: 1024px) {
+  .release-body {
+    grid-template-columns: minmax(0, 1fr) 21.5rem;
+    grid-template-areas: 'main aside';
+    align-items: start;
+  }
+  .release-main { grid-area: main; }
+  .release-aside {
+    grid-area: aside;
+    position: sticky;
+    top: calc(var(--header-h) + 1rem);
+    /* Plus haute que la fenêtre — obligation, bonus, cinq actions — elle
+       défile DANS sa boîte au lieu de laisser son bas inaccessible jusqu'à la
+       fin de la colonne de lecture. */
+    max-height: calc(100vh - var(--header-h) - 2rem);
+    overflow-y: auto;
+    scrollbar-width: thin;
+  }
+}
+
+/* Une section de lecture : un conteneur nommé pour le sommaire, sans boîte.
+   Vide (le composant n'a rien rendu, il ne reste qu'un commentaire), il
+   disparaît pour ne pas laisser un écart de grille orphelin. */
+.rsec:empty {
+  display: none;
+}
+/* Le tableau qui décide respire un peu plus que les sections de lecture. */
+.release-main > #versions { margin-block: 0.25rem 0.5rem; }
+
+/* ── Une seule coquille pour la colonne de lecture ───────────────────────
+ *
+ * La recette de `.panel` dans `me.vue` : surface, filet d'un pixel,
+ * `--radius-xl`. Posée ICI et non dans les composants : un style scopé atteint
+ * la racine d'un enfant, donc la page tient le rythme de sa pile pendant que
+ * chaque composant garde son intérieur. Hors coquille, délibérément : le
+ * bandeau d'identité (il a la sienne), la barre de commandes et le dock.
+ */
+.release-main .versions,
+.release-main .section,
+.release-main .nfo-panel,
+.release-main .tracks,
+.release-main .cm,
+.release-main > .related,
+.release-main > .operator-area,
+.release-main > .mod {
+  border: 1px solid rgb(var(--line-default));
+  border-radius: var(--radius-xl);
+  background: rgb(var(--bg-surface));
 }
-.adult-gate__title-word {
-  font-style: italic;
+.release-main .versions,
+.release-main .nfo-panel,
+.release-main .tracks,
+.release-main .cm,
+.release-main > .related,
+.release-main > .operator-area {
+  padding: 1rem 1rem 1.25rem;
 }
-.adult-gate__title-stamp {
+.section {
+  padding: 1rem 1.1rem;
+}
+/* La note repliée : une hauteur bornée et un fondu vers la surface, comme le
+   NFO. Le texte reste dans le document — rien n'est retiré, seulement caché à
+   l'œil jusqu'au clic ou à « tout afficher ». */
+.note-body--clamped {
   position: relative;
-  display: inline-flex;
-  padding: 0.2em 0.6em 0.25em;
-  background: rgb(var(--danger));
-  color: rgb(var(--danger-fg));  /* jeton sémantique : cette teinte était figée sur le thème sombre */
-  letter-spacing: calc(0.05em * var(--tracking-scale));
-  /* A faint, off-axis tilt to feel like an actual rubber-stamp impression. */
-  transform: rotate(-1.5deg);
-  box-shadow:
-    inset 0 0 0 2px rgba(255, 255, 255, 0.08),
-    0 1px 0 rgb(var(--shadow-color) / calc(0.4 * var(--shadow-strength)));
+  max-height: 26rem;
+  overflow: hidden;
 }
-.adult-gate__title-stamp::after {
+.note-body--clamped::after {
   content: '';
   position: absolute;
-  inset: -2px;
-  border: 2px dashed rgba(255, 255, 255, 0.18);
+  inset: auto 0 0 0;
+  height: 6rem;
+  background: linear-gradient(to bottom, transparent, rgb(var(--bg-surface)));
   pointer-events: none;
 }
-.adult-gate__title-stamp-inner {
-  position: relative;
-  display: inline-block;
-}
-
-.adult-gate__redacted {
-  display: flex;
-  flex-direction: column;
-  gap: 0.45rem;
-  margin: 0.5rem 0 0.25rem;
-}
-.adult-gate__redacted span {
-  display: block;
-  height: 0.95rem;
-  background: rgb(var(--fg-strong));
-  border-radius: 1px;
-  /* Three censorship bars approximating the title block — the eye
-     reads "there's a title here, you just don't see it". */
-  animation: gate-bar calc(1.2s * var(--motion-scale)) cubic-bezier(0.2, 0.6, 0.2, 1) both;
-}
-.adult-gate__redacted span:nth-child(1) { width: 78%; animation-delay: calc(0.05s * var(--motion-scale)); }
-.adult-gate__redacted span:nth-child(2) { width: 64%; animation-delay: var(--dur-1); }
-.adult-gate__redacted span:nth-child(3) { width: 42%; animation-delay: calc(0.19s * var(--motion-scale)); }
-@keyframes gate-bar {
-  0% { transform: scaleX(0.05); transform-origin: left; opacity: 0.2; }
-  60% { transform: scaleX(1.04); opacity: 1; }
-  100% { transform: scaleX(1); opacity: 1; }
+.note-more {
+  margin-top: 0.6rem;
+}
+
+/* Un doigt plutôt qu'une souris : les petites commandes passent à 36 px.
+   WCAG 2.5.8 se contente de 24 ; un pouce non. Mesuré à 390 px : pastilles
+   de fiche, puces de qualité, « +16 autres », les boutons de la carte
+   d'actions — tous à 24. */
+@media (pointer: coarse) {
+  .acts-list .btn,
+  .note-more,
+  .release-page :deep(.qc-chip),
+  .release-page :deep(.prov-user),
+  .release-page :deep(.idc-id),
+  .release-page :deep(.idc-crumb-link),
+  .release-page :deep(.versions-all),
+  .release-page :deep(.tsum-btn),
+  .release-page :deep(.idc .tool-btn--sm) {
+    min-height: 2.25rem;
+  }
+  .release-page :deep(.idc .tool-btn--sm) { min-width: 2.25rem; }
 }
 
-.adult-gate__meta {
-  display: grid;
-  grid-template-columns: repeat(3, minmax(0, 1fr));
-  gap: 0.65rem;
-  margin: 0.4rem 0 0.5rem;
-  padding: 0.85rem 1rem;
+/* ── La colonne de décision ─────────────────────────────────────────────── */
+.release-aside > .card {
   border: 1px solid rgb(var(--line-default));
-  border-radius: var(--radius-md);
-  background: rgb(var(--bg-elevated) / 0.6);
-}
-@media (max-width: 540px) {
-  .adult-gate__meta {
-    grid-template-columns: 1fr;
-  }
+  border-radius: var(--radius-xl);
+  background: rgb(var(--bg-surface));
 }
-
-/* ╔═══════════════════════════════════════════════════════════════╗
-   ║  MOBILE LAYOUT — keep every chip / button / data row usable    ║
-   ║  on a 360-420 px viewport. The fix-list is mostly about not    ║
-   ║  letting flex content overflow its parent (the InfoHash was    ║
-   ║  the worst offender — 40 hex chars in mono push past any 360-  ║
-   ║  px hero), and about giving touch targets enough room.         ║
-   ╚═══════════════════════════════════════════════════════════════╝ */
-@media (max-width: 640px) {
-  .release-page {
-    padding: 1.25rem 0.9rem 4rem;
-  }
-
-  /* ── Hero ────────────────────────────────────────────────── */
-  .hero {
-    padding: 1.25rem 1.1rem 1.2rem;
-    border-radius: var(--radius-lg);
-  }
-  .hero-eyebrow {
-    font-size: 0.5938rem;
-    letter-spacing: calc(0.18em * var(--tracking-scale));
-    gap: 0.4rem;
-  }
-  /* Report parks on its own line on mobile so the eyebrow doesn't
-     compete with the touch target on narrow screens. */
-  .hero-eyebrow-report {
-    margin-left: 0;
-    margin-top: 0.4rem;
-    flex-basis: 100%;
-    justify-content: center;
-  }
-  .hero-eyebrow-spacer { display: none; }
-
-  /* CTAs go vertical on mobile: Download stays the dominant signal
-     at full width, then Edit + Delete share the row below it. */
-  .hero-cta {
-    flex-direction: column;
-    align-items: stretch;
-    gap: 0.5rem;
-  }
-  .cta-primary {
-    justify-content: center;
-    padding: 0.9rem 1rem;
-  }
-  .cta-primary-stack { align-items: center; }
-  .hero-cta-aux {
-    display: grid;
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-    gap: 0.5rem;
-  }
-  .cta-ghost {
-    justify-content: center;
-    padding: 0.7rem 0.6rem;
-  }
-
-  /* Meta ribbon — the InfoHash overflow killer. On mobile the hash
-     cell takes the full row and the 40-hex string wraps onto a
-     second line. The uploader sits below, no `margin-left: auto`
-     so it doesn't try to push off the right edge. */
-  .hero-meta-cell--hash {
-    flex: 1 1 100%;
-    width: 100%;
-    flex-wrap: wrap;
-    gap: 0.4rem 0.65rem;
-  }
-  .hero-meta-cell--hash dd { flex: 1 1 100%; }
-  .hero-meta-hash {
-    font-size: 0.6563rem;
-    line-height: 1.45;
-  }
-  .hero-meta-cell--uploader {
-    margin-left: 0;
-    flex: 1 1 auto;
-  }
-
-  /* ── Section heads ───────────────────────────────────────── */
-  .section { margin-bottom: 1.75rem; }
-  .section-head {
-    gap: 0.5rem;
-    margin-bottom: 0.85rem;
-  }
-  .section-head-mark { font-size: 1.5rem; }
-  .section-head-title { font-size: 1.1rem; }
-
-  /* ── Stats cluster — two columns on mobile so a 5-metric row
-        doesn't become a 5-row stack that pushes the next section
-        below the fold. ──────────────────────────────────────── */
-  .stats-cluster {
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-    gap: 0.5rem;
-  }
-  .stat {
-    padding: 0.7rem 0.75rem;
-    gap: 0.6rem;
-  }
-  .stat-icon { font-size: 0.95rem; }
-  .stat-num { font-size: clamp(1.05rem, 4.5vw, 1.4rem); }
-  .stat-label {
-    font-size: 0.5313rem;
-    letter-spacing: calc(0.18em * var(--tracking-scale));
-  }
-
-  /* ── Note block ──────────────────────────────────────────── */
-  .note-block {
-    padding: 2.4rem 1.1rem 1rem 1.6rem;
-    font-size: 0.8438rem;
-    line-height: 1.6;
-  }
-  .note-block::before {
-    font-size: 2.1rem;
-    left: 0.55rem;
-    top: 0.3rem;
-  }
-
-  /* ── Cross-seed rows ─────────────────────────────────────── */
-  .cross-link { padding: 0.7rem 0.85rem; }
-  .cross-name { font-size: 0.7188rem; }
-  .cross-meta {
-    font-size: 0.5938rem;
-    letter-spacing: calc(0.08em * var(--tracking-scale));
-    width: 100%;
-    margin-top: 0.25rem;
-  }
-
-  /* ── Swarm table — already wraps in horizontal scroll, just
-        tighten the inner padding so we can see more on screen. */
-  .swarm-table thead th,
-  .swarm-table tbody td {
-    padding: 0.5rem 0.65rem;
-    font-size: 0.625rem;
-  }
-  .swarm-table thead th { font-size: 0.5625rem; letter-spacing: calc(0.16em * var(--tracking-scale)); }
+/* La carte de décision porte le seul geste de la page. Elle est SOULEVÉE —
+   ombre, bordure chaude — pour que l'œil sache où revenir. C'est le seul
+   panneau qui reçoit ce traitement, sinon ce n'en est plus un. */
+.release-aside > .dc {
+  border-color: rgb(var(--accent-warm) / 0.55);
+  box-shadow: var(--shadow-overlay);
 }
-.adult-gate__meta div {
+.aside-title {
   display: flex;
-  flex-direction: column;
-  gap: 0.2rem;
-}
-.adult-gate__meta dt {
+  align-items: center;
+  gap: 0.5rem;
+  margin: 0 0 0.6rem;
   font-family: var(--font-mono);
-  font-size: 0.5625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.18em * var(--tracking-scale));
+  font-size: var(--label-lg);
+  font-weight: var(--label-weight);
+  letter-spacing: var(--label-tracking);
   text-transform: uppercase;
   color: rgb(var(--fg-muted));
-  margin: 0;
 }
-.adult-gate__meta dd {
-  margin: 0;
-  font-family: var(--font-mono);
-  font-size: 0.7813rem;
-  font-weight: 700;
-  color: rgb(var(--fg-strong));
+.aside-title::after {
+  content: '';
+  flex: 1;
+  height: 1px;
+  background: rgb(var(--line-default));
 }
-
-.adult-gate__copy {
-  margin: 0;
-  font-size: 0.8125rem;
-  line-height: 1.55;
-  color: rgb(var(--fg-default));
-  max-width: 56ch;
+.acts {
+  padding: 0.85rem 0.9rem 0.9rem;
 }
-
-.adult-gate__actions {
+/* Une rangée qui s'enroule : cinq boutons tiennent sur deux lignes, là où une
+   liste d'un bouton par ligne montait à 250 px et faisait déborder la colonne
+   épinglée de la fenêtre. */
+.acts-list {
   display: flex;
   flex-wrap: wrap;
-  gap: 0.6rem;
-  margin-top: 0.4rem;
+  gap: 0.4rem;
 }
-.adult-gate__cta {
-  display: inline-flex;
+.acts-keys {
+  display: flex;
+  flex-wrap: wrap;
   align-items: center;
-  gap: 0.55rem;
-  padding: 0.7rem 1.05rem;
-  border: 1px solid rgb(var(--danger));
-  background: rgb(var(--danger));
-  color: rgb(var(--danger-fg));  /* jeton sémantique : cette teinte était figée sur le thème sombre */
-  font-family: var(--font-mono);
+  gap: 0.3rem 0.4rem;
+  margin: 0.75rem 0 0;
   font-size: 0.6875rem;
-  font-weight: 800;
-  letter-spacing: calc(0.18em * var(--tracking-scale));
-  text-transform: uppercase;
-  border-radius: var(--radius-pill);
-  transition: filter var(--dur-2);
-}
-.adult-gate__cta:hover {
-  filter: brightness(1.1);
-}
-.adult-gate__cta--ghost {
-  background: transparent;
-  color: rgb(var(--fg-strong));
-  border-color: rgb(var(--line-default));
-}
-.adult-gate__cta--ghost:hover {
-  border-color: rgb(var(--fg-default) / 0.4);
-  filter: none;
+  color: rgb(var(--fg-muted));
 }
-
-.adult-gate__foot {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 0.75rem;
-  padding: 0.65rem 1.1rem;
-  border-top: 1px dashed rgb(var(--line-default));
+.acts-keys-label {
   font-family: var(--font-mono);
-  font-size: 0.5938rem;
-  letter-spacing: calc(0.2em * var(--tracking-scale));
+  font-size: var(--label-sm);
+  font-weight: var(--label-weight);
+  letter-spacing: var(--label-tracking);
   text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-  background: rgb(var(--bg-surface));
-}
-.adult-gate__foot-mono {
-  text-transform: lowercase;
-  letter-spacing: calc(0.04em * var(--tracking-scale));
+  margin-right: 0.2rem;
+}
+.acts-keys kbd {
+  display: inline-grid;
+  place-items: center;
+  min-width: 1.3rem;
+  height: 1.3rem;
+  padding: 0 0.3rem;
+  border: 1px solid rgb(var(--line-strong));
+  border-bottom-width: 2px;
+  border-radius: var(--radius-sm);
+  background: rgb(var(--bg-elevated));
+  font-family: var(--font-mono);
+  font-size: 0.625rem;
+  font-weight: 700;
   color: rgb(var(--fg-default));
 }
+.acts-keys-sep { color: rgb(var(--fg-subtle)); }
 
-/* ── Reseed ask ───────────────────────────────────────────────────
-   Sits under the stat row it belongs to, separated by a rule rather than a
-   panel: it is a follow-up to the zero above it, not a section of its own. */
-.reseed-ask {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  flex-wrap: wrap;
-  gap: 0.75rem;
-  margin-top: 1rem;
-  padding-top: 0.9rem;
-  border-top: 1px solid rgb(var(--line-default));
-}
-.reseed-hint {
-  display: flex;
-  align-items: center;
-  gap: 0.45rem;
-  margin: 0;
-  max-width: 60ch;
-  font-size: 0.8125rem;
-  line-height: 1.5;
-  color: rgb(var(--fg-muted));
-}
-.reseed-icon {
-  flex-shrink: 0;
-  width: 1rem;
-  height: 1rem;
-  color: rgb(var(--accent));
+.fav-toggle[aria-pressed='true'] {
+  /* `--fg-strong` et non `--accent-warm-text` sur le voile chaud : peindre un
+     fond de la couleur du texte qu'il porte tombe sous 4,5:1 en thème clair.
+     Bordure à pleine opacité : c'est une bordure d'ÉTAT. */
+  border-color: rgb(var(--accent-warm));
+  background: rgb(var(--accent-warm) / 0.12);
+  color: rgb(var(--fg-strong));
 }
 
-/* ── Superseded banner ────────────────────────────────────────────
-   A banner rather than a list row for the "replaced by" direction: a member
-   who landed on an outdated release should be told before they press
-   download. The tone is informational, not a warning — the file is still
-   perfectly seedable, and colouring it red would say otherwise. */
-.supersede-banner {
-  display: flex;
-  gap: 0.75rem;
-  padding: 0.85rem 1rem;
-  margin-bottom: 1rem;
-  border: 1px solid rgb(var(--info) / 0.35);
-  border-radius: 0.5rem;
-  background: rgb(var(--info) / 0.08);
+.toc {
+  display: none;
+  padding: 0.85rem 0.9rem 0.9rem;
 }
-.supersede-banner-icon {
-  flex-shrink: 0;
-  width: 1.15rem;
-  height: 1.15rem;
-  margin-top: 0.1rem;
-  color: rgb(var(--info));
+/* Le sommaire est une commodité : sur un écran bas (portable en 768 px de
+   haut), il ferait déborder la colonne épinglée de la fenêtre, et un sommaire
+   qu'il faut faire défiler pour voir n'en est plus un. */
+@media (min-width: 1024px) and (min-height: 821px) {
+  .toc { display: block; }
 }
-.supersede-banner-body {
-  min-width: 0;
+.toc-list {
+  position: relative;
+  display: grid;
+  gap: 0.15rem;
+  margin: 0;
+  padding: 0;
+  list-style: none;
 }
-.supersede-banner-lead {
-  margin: 0 0 0.2rem;
-  font-size: 0.72rem;
-  letter-spacing: 0.09em;
-  text-transform: uppercase;
-  color: rgb(var(--fg-subtle));
+/* L'hôte ne dessine rien : le repère se positionne par rapport à la liste. */
+.toc-bar-host {
+  display: contents;
 }
-.supersede-banner-link {
-  font-weight: 600;
-  overflow-wrap: anywhere;
+.toc-bar {
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 2px;
+  border-radius: 1px;
+  background: rgb(var(--accent-warm));
+  transition: transform var(--dur-3) var(--ease-emphasis), height var(--dur-3) var(--ease-emphasis);
+  pointer-events: none;
 }
-.supersede-banner-reason,
-.supersede-banner-note {
-  margin: 0.35rem 0 0;
+.toc-link {
+  display: flex;
+  align-items: center;
+  gap: 0.6rem;
+  min-height: 1.75rem;
+  padding: 0 0.6rem;
+  border-left: 2px solid transparent;
+  border-radius: var(--radius-md);
   font-size: 0.8125rem;
-  line-height: 1.5;
   color: rgb(var(--fg-muted));
+  transition: color var(--dur-1) var(--ease-standard), background-color var(--dur-1) var(--ease-standard);
 }
-.supersede-banner-note {
-  color: rgb(var(--fg-subtle));
-  font-size: 0.75rem;
-}
-
-/* ── Buff badge (hero eyebrow) ────────────────────────────────────
-   Reads as a label, not a button: it states a fact about the release and
-   nothing about it is clickable. */
-.buff-badge {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.3rem;
-  padding: 0.1rem 0.45rem;
-  border: 1px solid rgb(var(--buff-tint) / 0.4);
-  border-radius: 0.25rem;
-  background: rgb(var(--buff-tint) / 0.12);
-  color: rgb(var(--buff-tint));
-  font-size: 0.66rem;
-  letter-spacing: 0.07em;
-  text-transform: uppercase;
-  white-space: nowrap;
+.toc-link:hover {
+  color: rgb(var(--fg-strong));
+  background: rgb(var(--bg-hover));
 }
-.buff-badge--freeleech    { --buff-tint: var(--online); }
-.buff-badge--silverleech  { --buff-tint: var(--info); }
-.buff-badge--doubleUpload { --buff-tint: var(--accent-warm); }
-.buff-badge--custom       { --buff-tint: var(--accent); }
-.buff-until {
-  opacity: 0.75;
-  text-transform: none;
-  letter-spacing: 0;
+.toc-link[aria-current='true'] {
+  color: rgb(var(--fg-strong));
+  background: rgb(var(--fg-default) / 0.04);
 }
-
-/* ── Staff tools ──────────────────────────────────────────────────── */
-.staff-block-title {
-  margin: 0 0 0.4rem;
-  font-size: 0.78rem;
-  letter-spacing: 0.08em;
-  text-transform: uppercase;
-  color: rgb(var(--fg-default));
+/* Sans mesure (avant le montage), le lien actif garde son filet propre. */
+.toc-list:not(:has(.toc-bar)) .toc-link[aria-current='true'] {
+  border-left-color: rgb(var(--accent-warm));
 }
-.staff-block-title--spaced {
-  margin-top: 2rem;
-  padding-top: 1.25rem;
-  border-top: 1px solid rgb(var(--line-default));
+.toc-n {
+  margin-left: auto;
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  font-weight: 600;
+  color: rgb(var(--fg-subtle));
+  font-variant-numeric: tabular-nums;
 }
 
-/* ── Staff buff panel ─────────────────────────────────────────────── */
-.buffs-lede {
-  margin: 0 0 1rem;
-  max-width: 62ch;
-  font-size: 0.8125rem;
-  line-height: 1.55;
-  color: rgb(var(--fg-muted));
-}
-.buffs-grid {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: flex-end;
-  gap: 0.85rem;
+/* ── L'entrée en scène ─────────────────────────────────────────────────── */
+/* Le premier écran seulement. La version précédente faisait monter TOUTES les
+   sections, celles hors écran comprises : du mouvement que personne ne voyait
+   et qui retardait ce qu'on lisait. Le héros mène (voir `IdentityCard`), les
+   pastilles apparaissent avec le décor, la carte de décision arrive en
+   dernier, à 200 ms — la séquence est finie à 400. Le reste est simplement là. */
+@keyframes release-rise {
+  from {
+    opacity: 0;
+    transform: translateY(0.375rem);
+  }
 }
-.buffs-field {
-  display: flex;
-  flex-direction: column;
-  gap: 0.3rem;
-  min-width: 11rem;
+@keyframes release-fade {
+  from { opacity: 0; }
 }
-.buffs-hint {
-  font-size: 0.7rem;
-  color: rgb(var(--fg-subtle));
+.page-bar {
+  animation: release-fade var(--dur-slow) var(--ease-standard) both;
 }
-.buffs-toggle {
-  display: flex;
-  align-items: center;
-  gap: 0.4rem;
-  padding-bottom: 0.55rem;
-  font-size: 0.8125rem;
+.release-aside > .dc {
+  animation: release-rise var(--dur-4) var(--ease-emphasis) both;
+  animation-delay: calc(200ms * var(--motion-scale));
 }
-.buffs-actions {
-  display: flex;
-  align-items: center;
-  gap: 0.6rem;
-  margin-top: 1rem;
+/* La teinte de l'œuvre sur le cadre de la carte de décision : un tiers de la
+   couleur de l'affiche dans l'or, en fondu quand l'échantillon arrive. */
+.release-aside > .dc { transition: border-color var(--dur-slow) var(--ease-standard); }
+.release-page--tinted .release-aside > .dc {
+  border-color: color-mix(in oklab, rgb(var(--accent-warm) / 0.55) 65%, rgb(var(--work-tint)));
 }
-
-@media (max-width: 40rem) {
-  .buffs-field {
-    flex: 1 1 100%;
-    min-width: 0;
-  }
+@media (prefers-reduced-motion: reduce) {
+  .page-bar,
+  .release-aside > .dc { animation: none; }
+  .toc-bar { transition: none; }
 }
-</style>
+</style>
\ No newline at end of file
diff --git a/apps/web/app/pages/torrents/fiche.vue b/apps/web/app/pages/torrents/fiche.vue
index c68a9ed1..a2059281 100644
--- a/apps/web/app/pages/torrents/fiche.vue
+++ b/apps/web/app/pages/torrents/fiche.vue
@@ -1343,7 +1343,7 @@ onMounted(() => {
 .fiche-results {
   display: grid;
   gap: 0.5rem;
-  grid-template-columns: repeat(auto-fill, minmax(15rem, 1fr));
+  grid-template-columns: repeat(auto-fill, minmax(min(100%, 15rem), 1fr));
   list-style: none;
   margin: 0;
   padding: 0;
@@ -1463,7 +1463,7 @@ onMounted(() => {
 .fiche-track-grid {
   display: grid;
   gap: 0.75rem 1rem;
-  grid-template-columns: repeat(auto-fit, minmax(11rem, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 11rem), 1fr));
 }
 .fiche-track-footer {
   display: flex;
@@ -1557,7 +1557,7 @@ onMounted(() => {
 }
 .fiche-options {
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(13rem, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 13rem), 1fr));
   gap: 0.6rem 1.25rem;
 }
 .fiche-check {
diff --git a/apps/web/app/pages/torrents/index.vue b/apps/web/app/pages/torrents/index.vue
index 8deffc03..7598ca3d 100644
--- a/apps/web/app/pages/torrents/index.vue
+++ b/apps/web/app/pages/torrents/index.vue
@@ -3,9 +3,14 @@
     <!-- ── Hero ──────────────────────────────────────────────── -->
     <header class="search-hero">
       <div class="search-hero-row">
-        <h1 class="search-title">
-          {{ $t('search.titleMain') }} <span class="search-title-faint">{{ $t('search.titleAccent') }}</span>
-        </h1>
+        <div class="search-heading">
+          <h1 class="search-title">
+            {{ $t('search.titleMain') }} <span class="search-title-faint">{{ $t('search.titleAccent') }}</span>
+          </h1>
+          <!-- Hors du h1 : un lecteur d'écran lisait « Recherche Torrents 9 releases ».
+               `role="status"` : le compte s'annonce quand les filtres changent. -->
+          <p class="search-count" role="status" aria-live="polite">{{ countLine }}</p>
+        </div>
         <div class="search-hero-actions">
           <NuxtLink
             to="/torrents/upload"
@@ -33,14 +38,18 @@
         </div>
       </div>
 
-      <SearchBar
-        v-model="searchQuery"
-        :placeholder="$t('search.searchPlaceholder')"
-        size="lg"
-        :loading="isLoading"
-        @search="handleSearch"
-        @media-id-search="handleMediaIdSearch"
-      />
+      <SearchTokenSearch
+          v-model="searchQuery"
+          :tokens="tokens"
+          :loading="isLoading"
+          :recent="recentSearches"
+          :recently-viewed="recentlyViewed"
+          @pick-work="onPickWork"
+          @pick-recent="onPickRecent"
+          @update:tokens="onTokens"
+          @search="handleSearch"
+          @media-id-search="handleMediaIdSearch"
+        />
 
       <!-- Active media-id chip + filters toggle row -->
       <div class="search-meta-row">
@@ -63,192 +72,233 @@
           </span>
         </Transition>
 
-        <button
-          type="button"
-          class="filters-toggle"
-          :class="{ 'filters-toggle--on': filtersOpen }"
-          :aria-expanded="filtersOpen"
-          aria-controls="search-filter-panel"
-          @click="filtersOpen = !filtersOpen"
-        >
-          <Icon :name="filtersOpen ? 'ph:funnel-fill' : 'ph:funnel'" />
-          {{ filtersOpen ? $t('torrents.hideFilters') : $t('torrents.showFilters') }}
-          <span v-if="selectedTags.length > 0" class="filters-toggle-count">
-            {{ selectedTags.length }}
-          </span>
-        </button>
       </div>
     </header>
 
+
     <!-- ── Categories (root row) ─────────────────────────────── -->
-    <section class="cats">
-      <p class="cats-eyebrow">{{ $t('common.category') }}</p>
-      <div class="cats-row">
+
+    <!-- ── Filters panel ─────────────────────────────────────── -->
+
+    <!-- ── Rail de facettes + résultats ─────────────────────────
+         Sur écran large le rail est toujours là, collant ; en dessous de 1100px
+         il se replie derrière le bouton « Afficher les filtres » de l'en-tête,
+         en attendant la feuille du téléphone. -->
+    <div class="layout">
+    <div v-if="filtersOpen" class="sheet-backdrop" @click="filtersOpen = false" />
+    <aside
+      id="search-filter-panel"
+      ref="railEl"
+      class="rail"
+      :class="{ 'rail--open': filtersOpen }"
+      :role="isNarrow && filtersOpen ? 'dialog' : undefined"
+      :aria-modal="isNarrow && filtersOpen ? 'true' : undefined"
+      :aria-label="$t('search.facets.title')"
+      @keydown.esc="filtersOpen = false"
+    >
+      <div class="sheet-head">
+        <h2 class="sheet-title rail-title" tabindex="-1">{{ $t('search.sheet.title') }}</h2>
+        <button v-if="hasActiveQuery" type="button" class="sheet-clear" @click="clearAllFilters">
+          {{ $t('search.filters.clearAll') }}
+        </button>
+        <button type="button" class="sheet-close" :aria-label="$t('search.sheet.close')" @click="filtersOpen = false">
+          <Icon name="ph:x-bold" aria-hidden="true" />
+        </button>
+      </div>
+      <!-- Sur écran étroit, le tri et la densité vivent dans la feuille : la
+           barre collante ne garde que les puces. -->
+      <div class="sheet-tools">
+        <label class="rbar-sort">
+          <span class="rbar-sort-k">{{ $t('search.sort.label') }}</span>
+          <select class="rbar-select" :value="effectiveSort" @change="setSort(($event.target as HTMLSelectElement).value)">
+            <option v-for="k in sortOptions" :key="k" :value="k">{{ $t(`search.sort.${k}`) }}</option>
+          </select>
+        </label>
+        <button type="button" class="rbar-ico" :aria-label="$t('search.sort.toggle')" @click="toggleOrder">
+          <Icon :name="sortOrder === 'asc' ? 'ph:sort-ascending-bold' : 'ph:sort-descending-bold'" aria-hidden="true" />
+        </button>
+        <div class="rbar-density" role="group" :aria-label="$t('search.density.label')">
+          <button type="button" :class="{ 'is-on': !dense }" :aria-pressed="!dense" :title="$t('search.density.comfortable')" @click="density = 'comfortable'">
+            <Icon name="ph:rows-bold" aria-hidden="true" />
+            <span class="sr-only">{{ $t('search.density.comfortable') }}</span>
+          </button>
+          <button type="button" :class="{ 'is-on': dense }" :aria-pressed="dense" :title="$t('search.density.compact')" @click="density = 'compact'">
+            <Icon name="ph:list-dashes-bold" aria-hidden="true" />
+            <span class="sr-only">{{ $t('search.density.compact') }}</span>
+          </button>
+        </div>
+      </div>
+      <!-- Les alertes en tête du rail : une section comme les autres, et le
+           rail a une raison d'être avant même le premier filtre. -->
+      <SearchAlertsStrip
+        rail
+        :can-save="hasActiveQuery && canSaveSearch"
+        :saving="savingSearch"
+        :version="alertsVersion"
+        @save="saveFromStrip"
+      />
+      <SearchCatalogueFacets
+        :facets="facets ?? null"
+        :loading="facetsPending"
+        :categories="categories ?? []"
+        :selected-category="selectedCategory"
+        :tokens="tokens"
+        :visible="catalogue.facets"
+        :options="options"
+        @select-category="handleCategorySelect"
+        @toggle-slug="onFacetSlug"
+        @toggle-year="onFacetYear"
+        @toggle-option="toggleOption"
+        :stats-at="facets?.statsAt ?? null"
+      />
+      <button type="button" class="sheet-apply" @click="filtersOpen = false">
+        {{ $t('search.sheet.apply', pagination.total) }}
+      </button>
+    </aside>
+    <section class="results" :aria-label="$t('search.results')">
+    <!-- ── Filtres actifs, tri, densité ──────────────────────────
+         Une barre collante : ce qui filtre la liste reste sous les yeux
+         pendant qu'on la parcourt, et chaque puce s'enlève d'un clic. Le tri
+         est un menu nommé plutôt qu'un en-tête de colonne cliquable, parce que
+         les lignes n'ont plus d'en-têtes sur mobile. -->
+    <div ref="rbarSentinel" class="rbar-sentinel" aria-hidden="true" />
+    <div class="rbar" :class="{ 'rbar--stuck': rbarStuck }" role="region" :aria-label="$t('search.filters.title')">
+      <div class="rbar-chips">
+        <button
+          v-if="selectedCategory"
+          type="button"
+          class="rbar-chip"
+          :aria-label="$t('search.tokens.remove', { label: $t('search.filters.category'), value: selectedCategoryName })"
+          @click="clearCategory"
+        >
+          <span class="rbar-chip-k">{{ $t('search.filters.category') }}</span>{{ selectedCategoryName }}
+          <Icon name="ph:x-bold" aria-hidden="true" />
+        </button>
+        <button
+          v-for="slug in selectedTags"
+          :key="`tag-${slug}`"
+          type="button"
+          class="rbar-chip"
+          :aria-label="$t('search.tokens.remove', { label: $t('search.filters.tag'), value: slug })"
+          @click="toggleTag(slug)"
+        >
+          <span class="rbar-chip-k">{{ $t('search.filters.tag') }}</span>{{ slug }}
+          <Icon name="ph:x-bold" aria-hidden="true" />
+        </button>
         <button
+          v-for="(tk, i) in tokens"
+          :key="`tk-${tk.kind}-${tk.value}`"
           type="button"
-          class="cat-pill"
-          :class="{ 'cat-pill--on': !selectedCategory }"
-          @click="handleCategorySelect('')"
+          class="rbar-chip rbar-chip--token"
+          :aria-label="$t('search.tokens.remove', { label: tokenKindLabel(tk.kind), value: tokenLabel(tk) })"
+          @click="removeToken(i)"
         >
-          <Icon name="ph:asterisk-bold" />
-          <span>{{ $t('common.all') }}</span>
+          <span class="rbar-chip-k">{{ tokenKindLabel(tk.kind) }}</span>{{ tokenLabel(tk) }}
+          <Icon name="ph:x-bold" aria-hidden="true" />
         </button>
         <button
-          v-for="cat in rootCategories"
-          :key="cat.id"
+          v-for="opt in options"
+          :key="`opt-${opt}`"
           type="button"
-          class="cat-pill"
-          :class="{
-            'cat-pill--on': selectedCategory === cat.id || hasActiveSub(cat),
-          }"
-          @click="handleCategorySelect(cat.id)"
+          class="rbar-chip rbar-chip--opt"
+          :aria-label="$t('search.tokens.remove', { label: $t('search.options.chip'), value: $t(`search.options.${opt}`) })"
+          @click="toggleOption(opt)"
         >
-          <Icon :name="categoryIcon(cat.slug)" />
-          <span>{{ cat.name }}</span>
+          <span class="rbar-chip-k">{{ $t('search.options.chip') }}</span>{{ $t(`search.options.${opt}`) }}
+          <Icon name="ph:x-bold" aria-hidden="true" />
         </button>
+        <button v-if="hasActiveQuery" type="button" class="rbar-clear" @click="clearAllFilters">
+          {{ $t('search.filters.clearAll') }}
+        </button>
+        <button
+          v-if="hasActiveQuery && !defaultsMatch"
+          type="button"
+          class="rbar-clear rbar-defaults"
+          :disabled="savingDefaults"
+          :title="$t('search.defaults.hint')"
+          @click="saveDefaults"
+        >
+          <Icon name="ph:push-pin-simple-bold" aria-hidden="true" />
+          {{ $t('search.defaults.save') }}
+        </button>
+        <button
+          v-else-if="defaultsMatch"
+          type="button"
+          class="rbar-clear rbar-defaults rbar-defaults--on"
+          :disabled="savingDefaults"
+          :title="$t('search.defaults.clear')"
+          @click="clearDefaults"
+        >
+          <Icon name="ph:push-pin-simple-fill" aria-hidden="true" />
+          {{ $t('search.defaults.active') }}
+        </button>
+        <!-- Sans filtre, la barre dit ce qu'elle montre : le compte, et la taille en vue Releases. -->
+        <span v-else-if="shownTotal > 0" class="rbar-sum">
+          <strong>{{ shownTotal }}</strong>
+          {{ view === 'grouped' ? $t('search.group.workCount', shownTotal) : $t('search.torrentCount', shownTotal) }}
+          <template v-if="totalSize > 0"> · {{ formatSize(totalSize) }}</template>
+        </span>
+        <span v-else class="rbar-none">{{ $t('search.filters.none') }}</span>
       </div>
-
-      <!-- Sub-categories — only render when the active root has children. -->
-      <Transition name="subs">
-        <div v-if="visibleSubcats.length > 0" class="cats-row cats-row--sub">
-          <button
-            v-for="sub in visibleSubcats"
-            :key="sub.id"
-            type="button"
-            class="cat-pill cat-pill--sub"
-            :class="{ 'cat-pill--on': selectedCategory === sub.id }"
-            @click="handleCategorySelect(sub.id)"
-          >
-            <span>{{ sub.name }}</span>
+      <div class="rbar-tools">
+        <!-- Seulement sur une instance qui a des partenaires : sur une instance
+             seule, les deux options donneraient la même liste. -->
+        <div
+          v-if="view === 'grouped' && (federated || sources === 'local')"
+          class="src-toggle"
+          :title="$t('search.group.sourcesHint')"
+        >
+          <button type="button" :class="{ 'src-on': sources === 'all' }" @click="sources = 'all'">
+            <Icon name="ph:broadcast-bold" />
+            {{ $t('search.group.sourcesAll') }}
+          </button>
+          <button type="button" :class="{ 'src-on': sources === 'local' }" @click="sources = 'local'">
+            <Icon name="ph:house-bold" />
+            {{ $t('search.group.sourcesLocal') }}
           </button>
         </div>
-      </Transition>
-    </section>
-
-    <!-- ── Filters panel ─────────────────────────────────────── -->
-    <Transition name="panel">
-      <div
-        v-if="filtersOpen"
-        id="search-filter-panel"
-        class="filter-panel"
-      >
-        <div class="filter-panel-head">
-          <p class="cats-eyebrow">{{ $t('search.tags') }}</p>
+        <label class="rbar-sort">
+          <span class="rbar-sort-k">{{ $t('search.sort.label') }}</span>
+          <select
+            class="rbar-select"
+            :value="effectiveSort"
+            @change="setSort(($event.target as HTMLSelectElement).value)"
+          >
+            <option v-for="k in sortOptions" :key="k" :value="k">{{ $t(`search.sort.${k}`) }}</option>
+          </select>
+        </label>
+        <button
+          type="button"
+          class="rbar-ico"
+          :aria-label="$t('search.sort.toggle')"
+          :title="sortOrder === 'asc' ? $t('search.sort.asc') : $t('search.sort.desc')"
+          @click="toggleOrder"
+        >
+          <Icon :name="sortOrder === 'asc' ? 'ph:sort-ascending-bold' : 'ph:sort-descending-bold'" aria-hidden="true" />
+        </button>
+        <div class="rbar-density" role="group" :aria-label="$t('search.density.label')">
           <button
-            v-if="selectedTags.length > 0"
             type="button"
-            class="filter-panel-clear"
-            @click="clearTagFilters"
+            :class="{ 'is-on': !dense }"
+            :aria-pressed="!dense"
+            :title="$t('search.density.comfortable')"
+            @click="density = 'comfortable'"
           >
-            {{ $t('search.clear') }}
+            <Icon name="ph:rows-bold" aria-hidden="true" />
+            <span class="sr-only">{{ $t('search.density.comfortable') }}</span>
           </button>
-        </div>
-        <div
-          v-if="(allTags?.length ?? 0) === 0"
-          class="filter-panel-empty"
-        >
-          {{ $t('search.noTags') }}
-        </div>
-        <div v-else class="filter-panel-tags">
           <button
-            v-for="tag in allTags"
-            :key="tag.id"
             type="button"
-            class="tag-toggle"
-            :class="{ 'tag-toggle--active': selectedTags.includes(tag.slug) }"
-            :style="
-              selectedTags.includes(tag.slug)
-                ? activeTagStyle(tag)
-                : undefined
-            "
-            @click="toggleTag(tag.slug)"
+            :class="{ 'is-on': dense }"
+            :aria-pressed="dense"
+            :title="$t('search.density.compact')"
+            @click="density = 'compact'"
           >
-            <span
-              class="inline-block w-2 h-2 rounded-full"
-              :style="{ backgroundColor: tag.color }"
-            />
-            {{ tag.name }}
+            <Icon name="ph:list-dashes-bold" aria-hidden="true" />
+            <span class="sr-only">{{ $t('search.density.compact') }}</span>
           </button>
         </div>
       </div>
-    </Transition>
-
-    <!-- ── Results header (stats + pagination top) ─────────── -->
-    <div
-      v-if="hasActiveQuery && pagination.total > 0"
-      class="results-head"
-    >
-      <div class="results-stats">
-<!-- Size is a flat-view fact; see `totalSize`. -->
-        <template v-if="totalSize > 0">
-          <span class="results-stat">
-            <Icon name="ph:hard-drive-bold" />
-            <strong>{{ formatSize(totalSize) }}</strong>
-          </span>
-          <span class="results-stat-sep" />
-        </template>
-        <span class="results-stat">
-          <strong>{{ pagination.total }}</strong>
-          {{
-            view === 'grouped'
-              ? $t('search.group.workCount', pagination.total)
-              : $t('search.torrentCount', pagination.total)
-          }}
-        </span>
-
-        <!-- Only on an instance that actually has partners. On a lone one the
-             two options would give identical results, and a control that never
-             changes anything is worse than no control. -->
-        <template v-if="view === 'grouped' && (federated || sources === 'local')">
-          <span class="results-stat-sep" />
-          <div class="src-toggle" :title="$t('search.group.sourcesHint')">
-            <button
-              type="button"
-              :class="{ 'src-on': sources === 'all' }"
-              @click="sources = 'all'"
-            >
-              <Icon name="ph:broadcast-bold" />
-              {{ $t('search.group.sourcesAll') }}
-            </button>
-            <button
-              type="button"
-              :class="{ 'src-on': sources === 'local' }"
-              @click="sources = 'local'"
-            >
-              <Icon name="ph:house-bold" />
-              {{ $t('search.group.sourcesLocal') }}
-            </button>
-          </div>
-        </template>
-      </div>
-      <Pager
-        v-if="pagination.pages > 1"
-        :page="pagination.page"
-        :pages="pagination.pages"
-        @go="goToPage"
-      />
-    </div>
-
-    <!-- ── Save this search ──────────────────────────────────────
-         Offered only when there is something to save. A filter is created
-         from here rather than from a form on the alerts page because the
-         member already has the criteria in front of them — retyping them
-         somewhere else is how a saved search ends up not matching what they
-         were actually looking at. -->
-    <div v-if="hasActiveQuery && canSaveSearch" class="save-search">
-      <button
-        type="button"
-        class="tool-btn tool-btn--text"
-        :disabled="savingSearch"
-        @click="saveCurrentSearch"
-      >
-        <Icon
-          :name="savingSearch ? 'ph:circle-notch' : 'ph:bookmark-simple-bold'"
-          :class="{ 'animate-spin': savingSearch }"
-        />
-        {{ $t('search.saveSearch.action') }}
-      </button>
-      <NuxtLink to="/alerts" class="save-search-link">{{ $t('search.saveSearch.manage') }}</NuxtLink>
     </div>
 
     <!-- ── Pinned ────────────────────────────────────────────────
@@ -257,41 +307,70 @@
          "read this one". Rendered with the same table so the columns line up
          with the flow underneath — a pin changes the position of a release,
          never how it is read. -->
-    <section v-if="pinnedTorrents.length > 0" class="pinned-block">
-      <header class="pinned-head">
-        <Icon name="ph:push-pin-fill" class="pinned-icon" />
-        <h2 class="pinned-title">{{ $t('search.pinned.title') }}</h2>
-        <span class="pinned-rule" />
-      </header>
-      <div class="card overflow-hidden">
-        <div class="overflow-x-auto">
-          <TorrentTable :torrents="pinnedTorrents" :compact="true" />
-        </div>
-      </div>
-    </section>
+
+    <!-- Vue Releases seulement : les épinglés arrivent avec la liste plate, que la
+         vue Œuvres ne recharge pas. Sans cette garde, ils restaient affichés après
+         un aller-retour Releases → Œuvres. -->
+    <SearchPinnedCards v-if="view === 'simple' && pinnedTorrents.length > 0" :torrents="pinnedTorrents" />
 
     <!-- ── Results body ──────────────────────────────────────── -->
-    <section v-if="hasActiveQuery">
-      <div v-if="isLoading" class="results-loading">
-        <Icon name="ph:circle-notch" class="animate-spin h-8 w-8" />
-        <p>{{ $t('search.searchingDatabase') }}</p>
+    <section :class="{ 'is-refreshing': isLoading && resultCount > 0 }" :aria-busy="isLoading">
+      <div v-if="isLoading && resultCount === 0 && pagination.total === 0" class="results-loading" role="status">
+        <span class="sr-only">{{ $t('search.searchingDatabase') }}</span>
+        <div v-for="n in 4" :key="n" class="skel" :style="{ '--i': n - 1 }" aria-hidden="true">
+          <span class="skel-pst" /><span class="skel-l skel-l--t" /><span class="skel-l skel-l--m" />
+        </div>
       </div>
-      <div v-else-if="resultCount === 0" class="results-empty">
-        <Icon name="ph:magnifying-glass-x" class="results-empty-icon" />
-        <h3>{{ $t('search.noResults') }}</h3>
-        <p>{{ $t('search.noResultsHint') }}</p>
+      <!-- Quand rien ne sort : ce que donne la même recherche sans chacun de
+           ses critères (les comptes viennent des facettes), puis demander la
+           release ou poser une alerte. Une page vide n'est pas un cul-de-sac. -->
+      <div v-else-if="resultCount === 0 && !isLoading" class="empty">
+        <div class="empty-main">
+          <h3 class="empty-title">{{ emptyTitle }}</h3>
+          <p class="empty-hint">{{ $t('search.empty.hint') }}</p>
+          <p v-if="facets?.didYouMean?.length" class="empty-dym">
+            <span>{{ $t('search.empty.didYouMean') }}</span>
+            <button
+              v-for="w in facets.didYouMean"
+              :key="`${w.source}:${w.externalId}`"
+              type="button"
+              class="empty-rel empty-rel--dym"
+              @click="onPickWork({ key: `${w.source}:${w.externalId}`, source: w.source as SuggestedWork['source'], externalId: w.externalId, title: w.title, year: null, posterUrl: null, releaseCount: 0 })"
+            >
+              {{ w.title }}
+            </button>
+          </p>
+          <ul v-if="emptySuggestions.length" class="empty-list">
+            <li v-for="sug in emptySuggestions" :key="sug.key">
+              <button type="button" class="empty-rel" @click="sug.apply">
+                <span>{{ sug.label }}</span>
+                <b>{{ sug.count }}</b>
+              </button>
+            </li>
+          </ul>
+        </div>
+        <div class="empty-act">
+          <NuxtLink to="/requests/new" class="empty-btn empty-btn--primary">
+            <Icon name="ph:hand-palm-bold" aria-hidden="true" />
+            {{ $t('search.empty.request') }}
+          </NuxtLink>
+          <button
+            v-if="canSaveSearch"
+            type="button"
+            class="empty-btn empty-btn--gold"
+            :disabled="savingSearch"
+            @click="saveFromStrip"
+          >
+            <Icon name="ph:bell-bold" aria-hidden="true" />
+            {{ $t('search.empty.alert') }}
+          </button>
+        </div>
       </div>
       <template v-else>
         <!-- Simple: classic table -->
         <div v-if="view === 'simple'" class="card overflow-hidden">
           <div class="overflow-x-auto">
-            <TorrentTable
-              :torrents="torrents"
-              :compact="false"
-              :sort-by="sortBy"
-              :order="sortOrder"
-              @sort="applySort"
-            />
+            <SearchReleaseRows :torrents="torrents" :dense="dense" group-versions />
           </div>
         </div>
         <!-- Grouped: one row per work, collapsed.
@@ -300,21 +379,33 @@
              episode, as season packs, as an integral — and each of those is a
              way in as well as a label. Opening a row is for choosing a file;
              finding out what exists happens without opening anything. -->
-        <div v-else class="card overflow-hidden">
-          <div class="overflow-x-auto">
-            <TorrentGroupTable
-              :groups="servedGroups"
-              :category-label="categoryLabel"
-              :sort-by="sortBy"
-              :order="sortOrder"
-              @sort="applySort"
-            />
-          </div>
-        </div>
+        <!-- Aucun panneau autour : `.card` peint `--bg-surface`, exactement la
+             couleur des cartes, si bien que les 8px d'écart se lisaient comme
+             une séparation INTERNE à un seul bloc. Ici chaque carte EST l'objet ;
+             le fond de la page doit passer entre elles. -->
+        <SearchWorkCards
+          v-else
+          :groups="servedGroups"
+          :category-label="categoryLabel"
+          :dense="dense"
+          :filter-query="committedFilterQuery"
+          :sort-by="effectiveSort"
+          :order="sortOrder"
+        />
       </template>
 
       <!-- Bottom pagination -->
       <div v-if="pagination.pages > 1 && resultCount > 0" class="results-foot">
+        <button
+          v-if="page + loadedPages <= pagination.pages"
+          type="button"
+          class="tool-btn tool-btn--text"
+          :disabled="loadingMore"
+          @click="loadMore"
+        >
+          <Icon :name="loadingMore ? 'ph:circle-notch' : 'ph:plus-bold'" :class="{ 'animate-spin': loadingMore }" aria-hidden="true" />
+          {{ $t('search.loadMore', { n: Math.max(1, Math.min(catalogue.pageSize, pagination.total - resultCount)) }) }}
+        </button>
         <p class="results-foot-summary">
           {{ $t('search.page') }} <strong>{{ pagination.page }}</strong> /
           {{ pagination.pages }}
@@ -331,23 +422,31 @@
     </section>
 
     <!-- ── Trending (when nothing's queried) ─────────────────── -->
-    <section v-else class="trending">
-      <p class="cats-eyebrow">{{ $t('search.trending') }}</p>
-      <div class="card overflow-hidden">
-        <TorrentTable
-          :torrents="trendingTorrents"
-          :compact="true"
-          :sort-by="sortBy"
-          :order="sortOrder"
-          @sort="applySort"
-        />
-      </div>
     </section>
+    </div>
   </div>
+
+    <!-- Sur écran étroit, le rail est une feuille : ce bouton l'ouvre et porte
+         le nombre de filtres posés. -->
+    <button
+      type="button"
+      ref="fabEl"
+      class="m-fab"
+      :aria-expanded="filtersOpen"
+      aria-controls="search-filter-panel"
+      @click="filtersOpen = !filtersOpen"
+    >
+      <Icon name="ph:funnel-bold" aria-hidden="true" />
+      {{ $t('search.sheet.open') }}
+      <span v-if="hasActiveQuery" class="m-fab-n">{{ pagination.total }}</span>
+    </button>
 </template>
 
 <script setup lang="ts">
 import { formatSize, formatAge } from '~/utils/format';
+import { tokensFromQuery, tokensToQuery, tokensToUrl, tokenSlugs, tokenLabel, toggleSlug, type SearchToken, type TagKind } from '~/utils/searchTokens';
+import { OPTION_KEYS, type FacetsResponse, type OptionKey } from '~/utils/catalogueFacets';
+import type { RecentSearch, SuggestedWork } from '~/components/search/TokenSearch.vue';
 import { TORRENT_SORT_KEYS } from '@trackarr/shared';
 import type { TorrentSortKey, SortDirection } from '@trackarr/shared';
 import Pager from '~/components/search/Pager.vue';
@@ -411,16 +510,376 @@ const route = useRoute();
 const router = useRouter();
 const { t } = useI18n();
 
-const searchQuery = ref((route.query.q as string) || '');
-const selectedCategory = ref((route.query.c as string) || '');
+/** Un paramètre répété (`?q=a&q=b`) arrive en tableau : on prend le premier, jamais le tableau. */
+const str = (v: unknown): string => (Array.isArray(v) ? String(v[0] ?? '') : typeof v === 'string' ? v : '');
+const searchQuery = ref(str(route.query.q));
+const selectedCategory = ref(str(route.query.c));
 const selectedTags = ref<string[]>(
-  ((route.query.tag as string) || '')
+  str(route.query.tag)
     .split(',')
     .map((s) => s.trim())
     .filter(Boolean)
 );
 const filtersOpen = ref(selectedTags.value.length > 0);
-const page = ref(parseInt((route.query.p as string) || '1', 10));
+/*
+ * Les jetons de la barre (résolution, codec, saison, année, @uploadeur…) :
+ * relus depuis l'URL au chargement, réécrits dedans à chaque changement, pour
+ * qu'une recherche se partage et se retrouve au retour arrière.
+ */
+const tokens = ref<SearchToken[]>(tokensFromQuery(route.query as Record<string, unknown>));
+/*
+ * La densité est un choix de lecture, pas de recherche : elle vit dans un
+ * cookie plutôt que dans l'URL, et vaut pour toutes les listes du site.
+ */
+const density = useCookie<'comfortable' | 'compact'>('trackarr-catalogue-density', {
+  default: () => 'comfortable',
+  maxAge: 60 * 60 * 24 * 365,
+  sameSite: 'lax',
+  path: '/',
+  httpOnly: false,
+});
+const dense = computed(() => density.value === 'compact');
+/*
+ * Les quatre options du rail — avec des sources, gratuit, pas encore pris,
+ * masquer les remplacées — vivent dans l'URL sous `o=seeded,free,…`, et se
+ * traduisent en drapeaux pour l'API (`minSeeders`, `freeleech`, `notTaken`,
+ * `hideSuperseded`).
+ */
+function optionsFromQuery(raw: unknown): OptionKey[] {
+  const str = typeof raw === 'string' ? raw : '';
+  return str.split(',').filter((k): k is OptionKey => (OPTION_KEYS as readonly string[]).includes(k));
+}
+function optionsToQuery(list: OptionKey[]) {
+  return {
+    minSeeders: list.includes('seeded') ? 1 : undefined,
+    freeleech: list.includes('free') ? '1' : undefined,
+    notTaken: list.includes('untaken') ? '1' : undefined,
+    hideSuperseded: list.includes('current') ? '1' : undefined,
+    favorites: list.includes('favorites') ? '1' : undefined,
+    since: list.includes('today') ? '24h' : undefined,
+  };
+}
+const options = ref<OptionKey[]>(optionsFromQuery(route.query.o));
+function toggleOption(key: OptionKey) {
+  options.value = options.value.includes(key)
+    ? options.value.filter((k) => k !== key)
+    : [...options.value, key];
+  page.value = 1;
+  updateUrl();
+}
+function onFacetSlug(kind: TagKind, slug: string) {
+  onTokens(toggleSlug(tokens.value, kind, slug));
+}
+function onFacetYear(year: number) {
+  const current = tokens.value.find((tk) => tk.kind === 'year');
+  const rest = tokens.value.filter((tk) => tk.kind !== 'year');
+  onTokens(current && Number(current.value) === year ? rest : [...rest, { kind: 'year', raw: String(year), value: String(year) }]);
+}
+/* ── Œuvres suggérées, recherches récentes ────────────────────────────────── */
+/**
+ * Choisir une œuvre dans les suggestions, c'est filtrer le catalogue sur elle :
+ * son identifiant TMDb devient le filtre de la page, dans la vue en cours. Les
+ * jeux et les livres n'ont pas de filtre d'identifiant ici — leur page de
+ * groupe fait le même travail.
+ */
+function onPickWork(work: SuggestedWork) {
+  if (work.source === 'tmdb') {
+    searchQuery.value = '';
+    mediaIdFilter.value = { source: 'tmdb', id: work.externalId };
+    page.value = 1;
+    updateUrl();
+    return;
+  }
+  router.push(`/torrents/group/${work.key}`);
+}
+const RECENT_LS_KEY = 'trackarr.recentSearches';
+const RECENT_MAX = 6;
+const recentSearches = ref<RecentSearch[]>([]);
+onMounted(() => {
+  try {
+    const raw = localStorage.getItem(RECENT_LS_KEY);
+    const parsed = raw ? (JSON.parse(raw) as RecentSearch[]) : [];
+    if (Array.isArray(parsed)) recentSearches.value = parsed.filter((r) => r && typeof r.label === 'string' && r.query).slice(0, RECENT_MAX);
+  } catch {
+    /* stockage indisponible : pas de récentes, rien de plus */
+  }
+});
+/** Une recherche validée par Entrée entre dans les récentes ; la même étiquette ne s'y répète pas. */
+function pushRecent() {
+  const label = [searchQuery.value.trim(), ...tokens.value.map((tk) => tokenLabel(tk))].filter(Boolean).join(' ');
+  if (!label) return;
+  const query = Object.fromEntries(
+    Object.entries(currentUrlQuery()).filter(([k, v]) => v !== undefined && k !== 'p'),
+  ) as Record<string, string>;
+  const next = [{ label, query }, ...recentSearches.value.filter((r) => r.label !== label)].slice(0, RECENT_MAX);
+  recentSearches.value = next;
+  try {
+    localStorage.setItem(RECENT_LS_KEY, JSON.stringify(next));
+  } catch {
+    /* idem */
+  }
+}
+function onPickRecent(query: Record<string, string>) {
+  // Le champ garde le focus (le panneau intercepte le mousedown) : le gardien
+  // de route, voyant « en train de taper », n'appliquerait pas `q`. On le pose ici.
+  searchQuery.value = query.q ?? '';
+  router.push({ path: '/torrents', query });
+}
+
+/* ── Les réglages du compte : « faire de ces filtres mon réglage » ─────────── */
+/*
+ * Le profil porte les filtres par défaut sous la forme de la chaîne de requête
+ * de cette page. Chargés côté client seulement (la page ne dépend pas d'eux
+ * pour se rendre) ; appliqués une fois, à l'arrivée sans aucun paramètre.
+ */
+const { data: me, refresh: refreshMe } = await useFetch<{ catalogueDefaults: Record<string, string> | null }>(
+  '/api/me',
+  { server: false, lazy: true },
+);
+const savedDefaults = computed(() => me.value?.catalogueDefaults ?? null);
+const savingDefaults = ref(false);
+let defaultsApplied = false;
+watch(
+  savedDefaults,
+  (d) => {
+    if (defaultsApplied || !d || Object.keys(d).length === 0) return;
+    defaultsApplied = true;
+    // « Sans paramètre » : la vue mémorisée (`v`) n'est pas un filtre, elle ne
+    // compte pas ; on la garde telle quelle à côté des réglages.
+    const others = Object.keys(route.query).filter((k) => k !== 'v');
+    if (others.length === 0) {
+      const v = typeof route.query.v === 'string' ? route.query.v : undefined;
+      router.replace({ path: '/torrents', query: v ? { ...d, v } : d });
+    }
+  },
+  { immediate: true },
+);
+const defaultsQuery = computed(() =>
+  Object.fromEntries(Object.entries(currentUrlQuery()).filter(([k, v]) => v !== undefined && k !== 'p')) as Record<string, string>,
+);
+const defaultsMatch = computed(() => {
+  const d = savedDefaults.value;
+  if (!d) return false;
+  const a = JSON.stringify(Object.entries(d).sort());
+  const b = JSON.stringify(Object.entries(defaultsQuery.value).map(([k, v]) => [k, String(v)]).sort());
+  return a === b;
+});
+async function saveDefaults() {
+  savingDefaults.value = true;
+  try {
+    await $fetch('/api/me', { method: 'PATCH', body: { catalogueDefaults: defaultsQuery.value } });
+    await refreshMe();
+    savedSearchNotifications.success(t('search.defaults.saved'));
+  } catch {
+    savedSearchNotifications.error(t('search.defaults.failed'));
+  } finally {
+    savingDefaults.value = false;
+  }
+}
+async function clearDefaults() {
+  savingDefaults.value = true;
+  try {
+    await $fetch('/api/me', { method: 'PATCH', body: { catalogueDefaults: null } });
+    await refreshMe();
+    savedSearchNotifications.success(t('search.defaults.cleared'));
+  } catch {
+    savedSearchNotifications.error(t('search.defaults.failed'));
+  } finally {
+    savingDefaults.value = false;
+  }
+}
+
+/* ── Vu récemment : les fiches ouvertes, gardées par le navigateur ─────────── */
+const recentlyViewed = ref<Array<{ hash: string; title: string }>>([]);
+onMounted(() => {
+  try {
+    const raw = localStorage.getItem('trackarr.recentlyViewed');
+    const parsed = raw ? (JSON.parse(raw) as Array<{ hash: string; title: string }>) : [];
+    if (Array.isArray(parsed)) recentlyViewed.value = parsed.filter((r) => r && typeof r.hash === 'string' && typeof r.title === 'string').slice(0, 8);
+  } catch {
+    /* rien de plus */
+  }
+});
+
+/* ── Le bandeau d'alertes : enregistrer d'ici, puis rafraîchir la liste ───── */
+const alertsVersion = ref(0);
+async function saveFromStrip() {
+  await saveCurrentSearch();
+  alertsVersion.value += 1;
+}
+
+/* ── La feuille de filtres sur écran étroit ───────────────────────────────── */
+const railEl = ref<HTMLElement | null>(null);
+/*
+ * Une barre qui colle porte une ombre ; posée dans le flux, aucune. Un témoin
+ * d'un pixel juste au-dessus dit lequel des deux : il sort de l'écran quand
+ * la barre s'accroche.
+ */
+const rbarSentinel = ref<HTMLElement | null>(null);
+const rbarStuck = ref(false);
+let rbarObserver: IntersectionObserver | null = null;
+onMounted(() => {
+  if (!rbarSentinel.value || typeof IntersectionObserver === 'undefined') return;
+  // La barre se colle sous l'en-tête du site, pas au bord de l'écran : le repère
+  // compte comme sorti dès qu'il passe sous cet en-tête, sinon l'état « collé »
+  // arrivait 64px trop tard.
+  const bar = rbarSentinel.value.nextElementSibling;
+  const stickTop = bar ? parseFloat(getComputedStyle(bar).top) || 0 : 0;
+  rbarObserver = new IntersectionObserver(
+    ([entry]) => {
+      rbarStuck.value = !!entry && !entry.isIntersecting;
+    },
+    { rootMargin: `-${Math.ceil(stickTop)}px 0px 0px 0px` },
+  );
+  rbarObserver.observe(rbarSentinel.value);
+});
+onBeforeUnmount(() => rbarObserver?.disconnect());
+// Sur écran étroit, le bouton flottant recouvre ce qui touche le bas de la
+// fenêtre : la page marque le corps pour que le pied de page se dégage.
+useHead({ bodyAttrs: { class: 'has-fab' } });
+const isNarrow = ref(false);
+let narrowQuery: MediaQueryList | null = null;
+const onNarrowChange = (e: MediaQueryListEvent | MediaQueryList) => {
+  isNarrow.value = e.matches;
+};
+onMounted(() => {
+  narrowQuery = window.matchMedia('(max-width: 68.75rem)');
+  onNarrowChange(narrowQuery);
+  narrowQuery.addEventListener('change', onNarrowChange);
+});
+onBeforeUnmount(() => {
+  narrowQuery?.removeEventListener('change', onNarrowChange);
+  if (import.meta.client) document.documentElement.style.overflow = '';
+});
+// Une feuille ouverte fige la page derrière elle et prend le focus ; fermée,
+// elle rend les deux.
+watch([filtersOpen, isNarrow], ([open, narrow], [wasOpen]) => {
+  if (!import.meta.client) return;
+  document.documentElement.style.overflow = open && narrow ? 'hidden' : '';
+  if (open && narrow) nextTick(() => railEl.value?.querySelector<HTMLElement>('.sheet-title')?.focus());
+  // Fermée, la feuille rend le focus au bouton qui l'a ouverte : au clavier, on
+  // ne repart pas du haut de la page.
+  else if (wasOpen && !open && narrow) nextTick(() => fabEl.value?.focus());
+});
+const fabEl = ref<HTMLElement | null>(null);
+
+/* ── L'état vide qui propose ──────────────────────────────────────────────── */
+const emptyTitle = computed(() => {
+  const words = [
+    searchQuery.value.trim(),
+    ...tokens.value.map((tk) => tokenLabel(tk)),
+    selectedCategoryName.value,
+    ...selectedTags.value,
+    ...options.value.map((o) => t(`search.options.${o}`)),
+    activeMediaId.value ? `${activeMediaId.value.label} ${activeMediaId.value.display}` : '',
+  ].filter(Boolean);
+  return words.length ? t('search.empty.title', { q: words.join(' ') }) : t('search.empty.titleNoQuery');
+});
+interface EmptySuggestion {
+  key: string;
+  label: string;
+  count: number;
+  apply: () => void;
+}
+const OPTION_BY_PARAM: Record<string, OptionKey> = {
+  minSeeders: 'seeded',
+  freeleech: 'free',
+  notTaken: 'untaken',
+  hideSuperseded: 'current',
+  favorites: 'favorites',
+  since: 'today',
+};
+const emptySuggestions = computed<EmptySuggestion[]>(() => {
+  const f = facets.value;
+  if (!f?.dropOne) return [];
+  const without = (what: string) => t('search.empty.without', { what });
+  const tagTokens = tokens.value.filter((tk) => tk.slugs?.length);
+  const out: EmptySuggestion[] = [];
+  for (const d of f.dropOne) {
+    const k = d.key;
+    if (k === 'search') {
+      out.push({ key: k, label: without(t('search.empty.text', { q: searchQuery.value.trim() })), count: d.count, apply: () => { searchQuery.value = ''; page.value = 1; updateUrl(); } });
+    } else if (k === 'categoryId') {
+      out.push({ key: k, label: without(selectedCategoryName.value), count: d.count, apply: clearCategory });
+    } else if (k === 'tag') {
+      out.push({ key: k, label: without(selectedTags.value.join(', ')), count: d.count, apply: () => { selectedTags.value = []; page.value = 1; updateUrl(); } });
+    } else if (k.startsWith('tagGroups:')) {
+      const tk = tagTokens[Number(k.slice('tagGroups:'.length))];
+      if (!tk) continue;
+      const idx = tokens.value.indexOf(tk);
+      out.push({ key: k, label: without(`${tokenKindLabel(tk.kind)} ${tokenLabel(tk)}`), count: d.count, apply: () => removeToken(idx) });
+    } else if (k === 'year' || k === 'season' || k === 'episode' || k === 'uploader') {
+      const idx = tokens.value.findIndex((tk) => tk.kind === k);
+      if (idx < 0) continue;
+      out.push({ key: k, label: without(tokenLabel(tokens.value[idx]!)), count: d.count, apply: () => removeToken(idx) });
+    } else if (k in OPTION_BY_PARAM) {
+      const opt = OPTION_BY_PARAM[k]!;
+      out.push({ key: k, label: without(t(`search.options.${opt}`)), count: d.count, apply: () => toggleOption(opt) });
+    } else if (k === 'imdbid' || k === 'tmdbid' || k === 'tvdbid') {
+      out.push({ key: k, label: without(activeMediaId.value ? `${activeMediaId.value.label} ${activeMediaId.value.display}` : k), count: d.count, apply: clearMediaIdFilter });
+    }
+  }
+  if (typeof f.catalogue === 'number' && f.catalogue > 0) {
+    out.push({ key: 'all', label: t('search.empty.all'), count: f.catalogue, apply: clearAllFilters });
+  }
+  return out;
+});
+
+const activeFilterCount = computed(
+  () =>
+    (selectedCategory.value ? 1 : 0) +
+    selectedTags.value.length +
+    tokens.value.length +
+    options.value.length +
+    (mediaIdFilter.value ? 1 : 0),
+);
+const tokenKindLabel = (kind: SearchToken['kind']) => t(`search.tokens.${kind}`);
+function clearCategory() {
+  selectedCategory.value = '';
+  page.value = 1;
+  updateUrl();
+}
+/*
+ * Une puce posée ou retirée dans la barre est un filtre appliqué : elle part
+ * dans l'URL tout de suite, comme un clic sur une catégorie — le texte libre,
+ * lui, n'y va qu'à Entrée, sinon chaque lettre ferait une entrée d'historique.
+ */
+function onTokens(next: SearchToken[]) {
+  tokens.value = next;
+  page.value = 1;
+  updateUrl();
+}
+function removeToken(index: number) {
+  tokens.value = tokens.value.filter((_, i) => i !== index);
+  page.value = 1;
+  updateUrl();
+}
+function clearAllFilters() {
+  searchQuery.value = '';
+  selectedCategory.value = '';
+  selectedTags.value = [];
+  tokens.value = [];
+  options.value = [];
+  mediaIdFilter.value = null;
+  page.value = 1;
+  updateUrl();
+}
+const SORT_KEYS = ['relevance', 'age', 'name', 'size', 'seeders', 'leechers', 'completed'] as const;
+const isSortKey = (key: string): key is (typeof SORT_KEYS)[number] =>
+  (SORT_KEYS as readonly string[]).includes(key);
+function setSort(key: string) {
+  if (!isSortKey(key)) return;
+  sortBy.value = key;
+  sortOrder.value = key === 'name' ? 'asc' : 'desc';
+  page.value = 1;
+  updateUrl();
+}
+function toggleOrder() {
+  sortOrder.value = sortOrder.value === 'asc' ? 'desc' : 'asc';
+  page.value = 1;
+  updateUrl();
+}
+const page = ref(Math.max(1, parseInt(str(route.query.p) || '1', 10) || 1));
 
 /**
  * Sort, in the URL so a sorted listing can be linked, bookmarked and walked
@@ -431,11 +890,17 @@ const page = ref(parseInt((route.query.p as string) || '1', 10));
  * twenty rows out of twelve thousand, which reads as a broken feature the
  * moment a member pages forward.
  */
-const sortBy = ref<TorrentSortKey>(
-  (TORRENT_SORT_KEYS as readonly string[]).includes(route.query.s as string)
-    ? (route.query.s as TorrentSortKey)
-    : 'age'
-);
+/*
+ * Le tri : `null` = automatique — pertinence dès qu'un texte est tapé, sinon le
+ * défaut de l'instance ; une valeur = le choix explicite du membre, et lui seul
+ * s'écrit dans l'URL.
+ */
+function sortKeyParam(v: unknown): TorrentSortKey | null {
+  return typeof v === 'string' && ['relevance', 'age', 'name', 'size', 'seeders', 'leechers', 'completed'].includes(v)
+    ? (v as TorrentSortKey)
+    : null;
+}
+const sortBy = ref<TorrentSortKey | null>(sortKeyParam(route.query.s));
 const sortOrder = ref<SortDirection>(
   (route.query.d as string) === 'asc' ? 'asc' : 'desc'
 );
@@ -471,8 +936,13 @@ function applySort(key: TorrentSortKey) {
 // key just fall back to the default — no migration needed since the
 // preference is trivial to re-set.
 const VIEW_LS_KEY = 'trackarr.torrents.view';
+/*
+ * Œuvres d'abord : sans `v` dans l'URL, le catalogue se range par œuvre —
+ * c'est ce qu'on cherche le plus souvent. La préférence mémorisée (ci-dessous,
+ * au montage) et un `?v=simple` partagé passent devant.
+ */
 const view = ref<'simple' | 'grouped'>(
-  (route.query.v as string) === 'grouped' ? 'grouped' : 'simple'
+  (route.query.v as string) === 'simple' ? 'simple' : 'grouped'
 );
 import {
   detectMediaId,
@@ -505,41 +975,68 @@ const activeMediaId = computed<DetectedMediaId | null>(() => {
 });
 
 const viewOptions = computed(() => [
-  { value: 'simple' as const, label: t('search.viewSimple'), icon: 'ph:list-bullets-bold' },
   { value: 'grouped' as const, label: t('search.viewGrouped'), icon: 'ph:squares-four-bold' },
+  { value: 'simple' as const, label: t('search.viewSimple'), icon: 'ph:list-bullets-bold' },
 ]);
 
 // Fetch categories — flat list with subcategories nested.
 const { data: categories } = await useFetch<Category[]>('/api/categories');
-const { data: allTags } = await useFetch<TorrentTag[]>('/api/tags');
-
-const rootCategories = computed<Category[]>(() => categories.value ?? []);
-
-// Resolve which root is "active" for the sub-row, even when the user picked
-// a sub-category directly (e.g. through a deep link). The sub-row stays
-// visible while any of the parent's children is selected.
-const activeRoot = computed<Category | null>(() => {
-  if (!selectedCategory.value) return null;
-  for (const cat of rootCategories.value) {
-    if (cat.id === selectedCategory.value) return cat;
-    const sub = cat.subcategories?.find(
-      (s) => s.id === selectedCategory.value
-    );
-    if (sub) return cat;
-  }
-  return null;
-});
 
-const visibleSubcats = computed<Category[]>(() =>
-  activeRoot.value?.subcategories ?? []
-);
 
-function hasActiveSub(cat: Category): boolean {
-  return cat.subcategories?.some((s) => s.id === selectedCategory.value)
-    ?? false;
-}
+
 
 // Fetch torrents — driven by every filter slice via a computed query.
+/*
+ * La marque et les réglages du catalogue AVANT les requêtes : leurs `computed`
+ * les lisent à la première évaluation (« Cannot access before initialization »).
+ */
+const branding = await useBranding();
+const federated = computed(() => Boolean(branding.value?.federationEnabled));
+/*
+ * Les réglages du catalogue de l'instance : vue et tri à l'arrivée, taille de
+ * page, facettes. Ils voyagent avec la marque, donc disponibles avant tout appel.
+ */
+const catalogue = computed(() => branding.value?.catalogue ?? {
+  defaultView: 'grouped' as const,
+  defaultSort: 'auto' as const,
+  pageSize: 20,
+  facets: ['category', 'resolution', 'source', 'codec', 'language', 'hdr', 'audio', 'year', 'options'],
+});
+if (!route.query.v) view.value = catalogue.value.defaultView;
+const effectiveSort = computed<TorrentSortKey>(() => {
+  if (sortBy.value) return sortBy.value;
+  if (catalogue.value.defaultSort !== 'auto') return catalogue.value.defaultSort;
+  return searchQuery.value.trim() ? 'relevance' : 'age';
+});
+// « Pertinence » n'est un choix que s'il y a un texte à classer.
+const sortOptions = computed(() =>
+  SORT_KEYS.filter((k) => k !== 'relevance' || searchQuery.value.trim() || effectiveSort.value === 'relevance'),
+);
+
+/** La requête du listing, nommée : « charger plus » la rejoue avec la page suivante. */
+const torrentsQuery = computed(() => {
+    const m = mediaIdFilter.value;
+    return {
+      // Coerce empty strings to undefined — the API's Zod schema requires
+      // min(1) on `search` and `categoryId`, so passing the literal empty
+      // string fails validation and the fetch returns 400.
+      search: searchQuery.value || undefined,
+      categoryId: selectedCategory.value || undefined,
+      tag:
+        selectedTags.value.length > 0
+          ? selectedTags.value.join(',')
+          : undefined,
+      imdbid: m?.source === 'imdb' ? m.id : undefined,
+      tmdbid: m?.source === 'tmdb' ? m.id : undefined,
+      tvdbid: m?.source === 'tvdb' ? m.id : undefined,
+      ...tokensToQuery(tokens.value),
+      ...optionsToQuery(options.value),
+      page: page.value,
+      limit: catalogue.value.pageSize,
+      sortBy: effectiveSort.value,
+      order: sortOrder.value,
+    };
+});
 const {
   data: torrentsData,
   pending,
@@ -560,27 +1057,7 @@ const {
     pages: number;
   };
 }>('/api/torrents', {
-  query: computed(() => {
-    const m = mediaIdFilter.value;
-    return {
-      // Coerce empty strings to undefined — the API's Zod schema requires
-      // min(1) on `search` and `categoryId`, so passing the literal empty
-      // string fails validation and the fetch returns 400.
-      search: searchQuery.value || undefined,
-      categoryId: selectedCategory.value || undefined,
-      tag:
-        selectedTags.value.length > 0
-          ? selectedTags.value.join(',')
-          : undefined,
-      imdbid: m?.source === 'imdb' ? m.id : undefined,
-      tmdbid: m?.source === 'tmdb' ? m.id : undefined,
-      tvdbid: m?.source === 'tvdb' ? m.id : undefined,
-      page: page.value,
-      limit: 20,
-      sortBy: sortBy.value,
-      order: sortOrder.value,
-    };
-  }),
+  query: torrentsQuery,
   // Refetching is driven by the explicit watcher below rather than by `watch:`,
   // so that typing in one view does not also fetch pages for the other.
   watch: false,
@@ -595,6 +1072,9 @@ const {
  */
 interface ServedGroup {
   key: string;
+  work?: { title: string; year: number | null; posterUrl: string | null; type: string | null; tint?: string | null } | null;
+  tagSlugs?: string[];
+  firstScope?: GroupScope;
   source: 'tmdb' | 'igdb' | 'openlibrary' | 'solo';
   externalId: string;
   releaseCount: number;
@@ -648,12 +1128,31 @@ const sources = ref<'all' | 'local'>('all');
  * already been switched to `local`, which is the one state you cannot
  * reach without it. Same flag the admin panels and the palette read.
  */
-const branding = await useBranding();
-const federated = computed(() => Boolean(branding.value?.federationEnabled));
 
 // Fetch groups — the grouped view's own endpoint. It folds the WHOLE catalogue,
 // not the page the flat listing happened to return, so its counts, episode sets
 // and pagination describe the catalogue rather than the window.
+const groupsQuery = computed(() => ({
+    search: searchQuery.value || undefined,
+    categoryId: selectedCategory.value || undefined,
+    // Les tags, comme le listing plat. Ils manquaient ICI autant que dans le
+    // schéma du endpoint : la vue groupée rendait le catalogue entier pour un
+    // `?tag=2160p`, et rien ne le signalait puisque zod retire en silence ce
+    // qu'il ne déclare pas. Le défaut était des deux côtés du fil.
+    tag: selectedTags.value.length > 0 ? selectedTags.value.join(',') : undefined,
+    sources: sources.value,
+    imdbid: mediaIdFilter.value?.source === 'imdb' ? mediaIdFilter.value.id : undefined,
+    tmdbid: mediaIdFilter.value?.source === 'tmdb' ? mediaIdFilter.value.id : undefined,
+    tvdbid: mediaIdFilter.value?.source === 'tvdb' ? mediaIdFilter.value.id : undefined,
+    ...tokensToQuery(tokens.value),
+    ...optionsToQuery(options.value),
+    page: page.value,
+    limit: catalogue.value.pageSize,
+    // Same keys as the flat listing: switching views keeps the order, even
+    // though what each key means across a group is decided server-side.
+    sortBy: effectiveSort.value,
+    order: sortOrder.value,
+}));
 const {
   data: groupsData,
   pending: groupsPending,
@@ -664,17 +1163,7 @@ const {
   merged: boolean;
   pagination: { page: number; limit: number; total: number; totalPages: number };
 }>('/api/torrents/groups', {
-  query: computed(() => ({
-    search: searchQuery.value || undefined,
-    categoryId: selectedCategory.value || undefined,
-    sources: sources.value,
-    page: page.value,
-    limit: 25,
-    // Same keys as the flat listing: switching views keeps the order, even
-    // though what each key means across a group is decided server-side.
-    sortBy: sortBy.value,
-    order: sortOrder.value,
-  })),
+  query: groupsQuery,
   watch: false,
   immediate: view.value === 'grouped',
 });
@@ -683,12 +1172,73 @@ const {
 // One watcher for both endpoints: whichever view is on screen is the one that
 // refetches. Switching views is itself a trigger, so the first switch loads the
 // side that was skipped at mount.
+/*
+ * Les mêmes critères que le listing, sans page ni tri : c'est ce que le rail
+ * compte, et ce que les cartes d'œuvres passent à leurs releases dépliées.
+ */
+const committedFilterQuery = ref<Record<string, string | number | undefined>>({});
+const workFilterQuery = computed(() => {
+  const m = mediaIdFilter.value;
+  return {
+    search: searchQuery.value || undefined,
+    categoryId: selectedCategory.value || undefined,
+    tag: selectedTags.value.length > 0 ? selectedTags.value.join(',') : undefined,
+    imdbid: m?.source === 'imdb' ? m.id : undefined,
+    tmdbid: m?.source === 'tmdb' ? m.id : undefined,
+    tvdbid: m?.source === 'tvdb' ? m.id : undefined,
+    ...tokensToQuery(tokens.value),
+    ...optionsToQuery(options.value),
+  };
+});
+/*
+ * Semé ici, et pas seulement dans `refreshAll()` : au PREMIER chargement aucun
+ * rafraîchissement n'a lieu, et une carte dépliée interrogeait alors l'API sans
+ * les filtres de la page — sur `?c=<catégorie>`, elle listait des releases que
+ * la page excluait. L'affectation a lieu une fois, au montage, des deux côtés.
+ */
+committedFilterQuery.value = workFilterQuery.value;
+const {
+  data: facets,
+  pending: facetsPending,
+  refresh: refreshFacets,
+} = await useFetch<FacetsResponse>('/api/torrents/facets', {
+  query: workFilterQuery,
+  watch: false,
+});
+
+/*
+ * Le texte tapé attend 250 ms de silence avant de relancer les trois lectures
+ * (listing, facettes, groupes) ; les clics — puces, catégorie, tri, page —
+ * partent tout de suite. Une lettre ne vaut pas trois requêtes.
+ */
+let typingTimer: ReturnType<typeof setTimeout> | null = null;
+function refreshAll() {
+  resetExtra();
+  // Ce que les cartes d'œuvres dépliées interrogent : la requête telle qu'elle
+  // est partie, pas la frappe en cours — sinon chaque touche rechargeait
+  // chaque carte ouverte, sans le délai que la page s'accorde.
+  committedFilterQuery.value = workFilterQuery.value;
+  if (view.value === 'grouped') refreshGroups();
+  else refreshTorrents();
+  refreshFacets();
+}
+watch(searchQuery, () => {
+  if (typingTimer) clearTimeout(typingTimer);
+  typingTimer = setTimeout(() => {
+    typingTimer = null;
+    refreshAll();
+  }, 250);
+});
+onBeforeUnmount(() => {
+  if (typingTimer) clearTimeout(typingTimer);
+});
 watch(
   [
-    searchQuery,
     selectedCategory,
     selectedTags,
     mediaIdFilter,
+    tokens,
+    options,
     page,
     view,
     sources,
@@ -696,18 +1246,60 @@ watch(
     sortOrder,
   ],
   () => {
-    if (view.value === 'grouped') refreshGroups();
-    else refreshTorrents();
+    if (typingTimer) {
+      clearTimeout(typingTimer);
+      typingTimer = null;
+    }
+    refreshAll();
   }
 );
 
 // Trending — surface 10 latest torrents when there's no query.
-const { data: trendingData } = await useFetch<{ data: TorrentWithStats[] }>(
-  '/api/torrents',
-  { query: { limit: 10 } }
-);
 
-const torrents = computed(() => torrentsData.value?.data ?? []);
+/*
+ * « Charger plus » : les pages suivantes s'ajoutent sous la première au lieu de
+ * la remplacer, et la position ne bouge pas. Un changement de filtre ou de tri
+ * repart de zéro.
+ */
+const extraTorrents = ref<TorrentWithStats[]>([]);
+const extraGroups = ref<ServedGroup[]>([]);
+const loadedPages = ref(1);
+const loadingMore = ref(false);
+/* La génération des pages ajoutées : `resetExtra()` l'incrémente, et une page
+   partie avant un changement de filtre, de tri ou de vue est ignorée à l'arrivée. */
+let extraGen = 0;
+async function loadMore() {
+  if (loadingMore.value) return;
+  const next = page.value + loadedPages.value;
+  if (next > pagination.value.pages) return;
+  const gen = extraGen;
+  loadingMore.value = true;
+  try {
+    if (view.value === 'grouped') {
+      const res = await $fetch<{ groups: ServedGroup[] }>('/api/torrents/groups', {
+        query: { ...groupsQuery.value, page: next },
+      });
+      if (gen !== extraGen) return;
+      extraGroups.value = [...extraGroups.value, ...res.groups];
+    } else {
+      const res = await $fetch<{ data: TorrentWithStats[] }>('/api/torrents', {
+        query: { ...torrentsQuery.value, page: next },
+      });
+      if (gen !== extraGen) return;
+      extraTorrents.value = [...extraTorrents.value, ...res.data];
+    }
+    loadedPages.value += 1;
+  } finally {
+    loadingMore.value = false;
+  }
+}
+function resetExtra() {
+  extraGen += 1;
+  extraTorrents.value = [];
+  extraGroups.value = [];
+  loadedPages.value = 1;
+}
+const torrents = computed(() => [...(torrentsData.value?.data ?? []), ...extraTorrents.value]);
 const pinnedTorrents = computed(() => torrentsData.value?.pinned ?? []);
 
 /**
@@ -724,6 +1316,8 @@ const canSaveSearch = computed(
     !!searchQuery.value.trim() ||
     !!selectedCategory.value ||
     selectedTags.value.length > 0 ||
+    tokens.value.length > 0 ||
+    options.value.length > 0 ||
     // A filter by IMDb/TMDb/TVDB id counts. The route has accepted these three
     // since it was written and `/alerts` renders a chip for each, but the only
     // thing that creates a saved search never sent them — so the chips were
@@ -752,6 +1346,9 @@ async function saveCurrentSearch() {
     fromMedia ||
     t('search.saveSearch.untitled')
   ).slice(0, 80);
+  // Une recherche enregistrée ne connaît que des slugs : chaque jeton d'étiquette
+  // y laisse son premier synonyme, les numéros et l'uploadeur n'y entrent pas.
+  const savedTags = [...selectedTags.value, ...tokenSlugs(tokens.value)];
   savingSearch.value = true;
   try {
     await $fetch<{ id: string }>('/api/me/saved-searches', {
@@ -760,7 +1357,13 @@ async function saveCurrentSearch() {
         label,
         query: searchQuery.value.trim() || undefined,
         categoryId: selectedCategory.value || undefined,
-        tags: selectedTags.value.length ? selectedTags.value : undefined,
+        tags: savedTags.length ? savedTags : undefined,
+        // Les critères de la barre, pour que l'alerte reproduise la recherche.
+        tagGroups: tokensToQuery(tokens.value).tagGroups,
+        season: tokensToQuery(tokens.value).season ? Number(tokensToQuery(tokens.value).season) : undefined,
+        episode: tokensToQuery(tokens.value).episode ? Number(tokensToQuery(tokens.value).episode) : undefined,
+        year: tokensToQuery(tokens.value).year ? Number(tokensToQuery(tokens.value).year) : undefined,
+        uploader: tokensToQuery(tokens.value).uploader,
         imdbId: mediaIdFilter.value?.source === 'imdb' ? mediaIdFilter.value.id : undefined,
         tmdbId: mediaIdFilter.value?.source === 'tmdb' ? mediaIdFilter.value.id : undefined,
         tvdbId: mediaIdFilter.value?.source === 'tvdb' ? mediaIdFilter.value.id : undefined,
@@ -786,7 +1389,6 @@ async function saveCurrentSearch() {
     savingSearch.value = false;
   }
 }
-const trendingTorrents = computed(() => trendingData.value?.data ?? []);
 
 // ── View-aware result state ──────────────────────────────────
 //
@@ -829,6 +1431,8 @@ const hasActiveQuery = computed(
     Boolean(searchQuery.value) ||
     Boolean(selectedCategory.value) ||
     selectedTags.value.length > 0 ||
+    tokens.value.length > 0 ||
+    options.value.length > 0 ||
     Boolean(activeMediaId.value) ||
     // Sorting is a query too. Clicking "size" on the landing view means "show
     // me the biggest releases", which is a question about the catalogue — not
@@ -837,16 +1441,34 @@ const hasActiveQuery = computed(
 );
 
 /** True once the user has moved off the default ordering. */
-const isSorted = computed(
-  () => sortBy.value !== 'age' || sortOrder.value !== 'desc'
-);
+const isSorted = computed(() => sortBy.value !== null || sortOrder.value !== 'desc');
 
 /**
  * The groups as served. No adaptation layer: the row component consumes the
  * API's shape directly, because there is no longer a client-side grouping for
  * it to be reconciled with.
  */
-const servedGroups = computed(() => groupsData.value?.groups ?? []);
+const servedGroups = computed(() => [...(groupsData.value?.groups ?? []), ...extraGroups.value]);
+/*
+ * Le nombre de la barre. En vue Releases, la liste plate met l'épinglée à part
+ * et sa pagination ne la compte pas : « 35 torrents » sous un titre qui dit
+ * « 36 releases ». Les facettes comptent tout ce qui répond, épinglée comprise.
+ */
+const shownTotal = computed(() =>
+  view.value === 'grouped' ? pagination.value.total : facets.value?.total ?? pagination.value.total,
+);
+/* Sous le titre : ce que la recherche courante recouvre. */
+const countLine = computed(() => {
+  const f = facets.value;
+  if (!f) return '';
+  const parts = [t('search.count.releases', f.total)];
+  if (view.value === 'grouped' && groupsData.value?.pagination) parts.push(t('search.count.works', groupsData.value.pagination.total));
+  if (f.options.withSeeders > 0) parts.push(t('search.count.live', f.options.withSeeders));
+  return parts.join(' · ');
+});
+const selectedCategoryName = computed(() =>
+  selectedCategory.value ? categoryLabel([selectedCategory.value]) ?? '' : '',
+);
 
 /**
  * Resolve a group's category to a label here rather than handing the row the
@@ -873,24 +1495,11 @@ const categoryById = computed(() => {
   return map;
 });
 
-function categoryIcon(slug: string): string {
-  const icons: Record<string, string> = {
-    movies: 'ph:film-slate-bold',
-    tv: 'ph:television-bold',
-    music: 'ph:music-notes-bold',
-    games: 'ph:game-controller-bold',
-    software: 'ph:app-window-bold',
-    ebooks: 'ph:book-open-bold',
-    anime: 'ph:shooting-star-bold',
-    xxx: 'ph:prohibit-bold',
-    other: 'ph:package-bold',
-  };
-  return icons[slug] || 'ph:folder-bold';
-}
 
 function handleSearch() {
   page.value = 1;
   updateUrl();
+  pushRecent();
 }
 
 function handleCategorySelect(id: string) {
@@ -907,10 +1516,10 @@ function goToPage(p: number) {
   }
 }
 
-function updateUrl() {
+/** La requête d'URL que la page écrit — et ce qu'une recherche récente retient. */
+function currentUrlQuery(): Record<string, string | number | undefined> {
   const m = mediaIdFilter.value;
-  router.replace({
-    query: {
+  return {
       q: searchQuery.value || undefined,
       c: selectedCategory.value || undefined,
       tag:
@@ -920,18 +1529,32 @@ function updateUrl() {
       imdbid: m?.source === 'imdb' ? m.id : undefined,
       tmdbid: m?.source === 'tmdb' ? m.id : undefined,
       tvdbid: m?.source === 'tvdb' ? m.id : undefined,
+      ...tokensToUrl(tokens.value),
+      o: options.value.length ? options.value.join(',') : undefined,
       p: page.value > 1 ? page.value : undefined,
-      v: view.value === 'grouped' ? 'grouped' : undefined,
+      // Seule une vue différente du défaut de l'instance s'écrit.
+      v: view.value !== catalogue.value.defaultView ? view.value : undefined,
       // Omitted while on the default so a plain listing keeps a clean URL.
-      s: sortBy.value !== 'age' ? sortBy.value : undefined,
+      s: sortBy.value ?? undefined,
       d: sortOrder.value !== 'desc' ? sortOrder.value : undefined,
-    },
-  });
+  };
+}
+function updateUrl() {
+  router.replace({ query: currentUrlQuery() as Record<string, string> });
 }
 
 watch(view, (next) => {
-  page.value = 1;
-  updateUrl();
+  /*
+   * Une bascule VOULUE repart de la première page et écrit l'URL. Un changement
+   * que l'URL porte déjà — retour arrière, lien `?v=simple` du menu — n'est pas
+   * une bascule : le réécrire effaçait le `p=3` vers lequel on revenait.
+   */
+  const urlView = str(route.query.v);
+  const fromUrl = urlView ? urlView === next : next === catalogue.value.defaultView;
+  if (!fromUrl) {
+    page.value = 1;
+    updateUrl();
+  }
   // Persist the user's choice across reloads. We only touch localStorage
   // on the client; the early ref init runs identically on server and
   // client to avoid hydration mismatches.
@@ -983,35 +1606,32 @@ function toggleTag(slug: string) {
   updateUrl();
 }
 
-function clearTagFilters() {
-  selectedTags.value = [];
-  page.value = 1;
-  updateUrl();
-}
 
-function activeTagStyle(tag: { color: string }) {
-  const hex = (tag.color || '').replace('#', '').toLowerCase();
-  const isDefault = !/^[0-9a-f]{6}$/i.test(hex) || hex === '6b7280';
-  if (isDefault) {
-    return {
-      backgroundColor: 'rgb(var(--fg-default) / 0.18)',
-      borderColor: 'rgb(var(--fg-default))',
-      color: 'rgb(var(--fg-strong))',
-    };
-  }
-  return {
-    backgroundColor: `#${hex}3d`,
-    borderColor: `#${hex}`,
-    color: 'rgb(var(--fg-strong))',
-  };
-}
 
 watch(
   () => route.query,
   (newQuery) => {
-    searchQuery.value = (newQuery.q as string) || '';
-    selectedCategory.value = (newQuery.c as string) || '';
-    selectedTags.value = ((newQuery.tag as string) || '')
+    /*
+     * Deux gardes. La première : un `router.replace` que la page a elle-même
+     * écrit revient ici une fois résolu — rien à relire. La seconde : quand le
+     * membre est en train de taper, le champ est la vérité ; une navigation qui
+     * se résout pendant la frappe (un clic sur le rail juste avant) ne doit pas
+     * effacer ce qu'il vient d'écrire.
+     */
+    const own = currentUrlQuery();
+    const normalize = (q: Record<string, unknown>) =>
+      Object.entries(q)
+        .filter(([, v]) => v !== undefined && v !== null && v !== '')
+        .map(([k, v]) => `${k}=${String(v)}`)
+        .sort()
+        .join('&');
+    if (normalize(own) === normalize(newQuery as Record<string, unknown>)) return;
+    const typing =
+      import.meta.client &&
+      (document.activeElement as HTMLElement | null)?.classList.contains('ts-input') === true;
+    if (!typing) searchQuery.value = str(newQuery.q);
+    selectedCategory.value = str(newQuery.c);
+    selectedTags.value = str(newQuery.tag)
       .split(',')
       .map((s) => s.trim())
       .filter(Boolean);
@@ -1024,8 +1644,13 @@ watch(
     } else {
       mediaIdFilter.value = null;
     }
-    page.value = parseInt((newQuery.p as string) || '1', 10);
-    view.value = (newQuery.v as string) === 'grouped' ? 'grouped' : 'simple';
+    page.value = Math.max(1, parseInt(str(newQuery.p) || '1', 10) || 1);
+    tokens.value = tokensFromQuery(newQuery as Record<string, unknown>);
+    options.value = optionsFromQuery(newQuery.o);
+    view.value = newQuery.v === 'simple' || newQuery.v === 'grouped' ? newQuery.v : catalogue.value.defaultView;
+    // Le tri aussi : le retour arrière doit rendre l'ordre qu'on avait, pas le défaut.
+    sortBy.value = sortKeyParam(newQuery.s);
+    sortOrder.value = newQuery.d === 'asc' ? 'asc' : 'desc';
   },
   { deep: true }
 );
@@ -1036,6 +1661,26 @@ useHead({
 </script>
 
 <style scoped>
+.search-heading {
+  display: flex;
+  align-items: baseline;
+  flex-wrap: wrap;
+  gap: 0.35rem 0.9rem;
+  min-width: 0;
+}
+.search-count {
+  display: block;
+  margin: 0;
+  min-height: 1em;
+  color: rgb(var(--accent-warm-text) / 1);
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  font-weight: 500;
+  line-height: 1;
+  letter-spacing: 0.04em;
+  color: rgb(var(--fg-muted) / 1);
+}
+
 /* =============================================================================
  * Torrents hub — chip-driven category navigation à la C411.
  *
@@ -1051,15 +1696,29 @@ useHead({
 .search-shell {
   display: flex;
   flex-direction: column;
-  gap: 1.25rem;
+  gap: 1.5rem;
   padding-bottom: 4rem;
 }
 
 /* ─── Hero ───────────────────────────────────────────────── */
 .search-hero {
+  position: relative;
   display: flex;
   flex-direction: column;
-  gap: 0.85rem;
+  gap: 1rem;
+}
+/* Le grain de la fiche, très bas, sur l'en-tête seulement : la page a une
+   matière au lieu d'un fond plat. Rien à cliquer dessous. */
+.search-hero::before {
+  content: '';
+  position: absolute;
+  inset: -1.5rem -1rem 0;
+  z-index: -1;
+  pointer-events: none;
+  border-radius: var(--radius-xl);
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='160' height='160'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.85' numOctaves='2' stitchTiles='stitch'/%3E%3CfeColorMatrix values='0 0 0 0 0.5 0 0 0 0 0.5 0 0 0 0 0.5 0 0 0 0.05 0'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)'/%3E%3C/svg%3E");
+  mask-image: linear-gradient(rgb(0 0 0 / 1), rgb(0 0 0 / 0));
+  -webkit-mask-image: linear-gradient(rgb(0 0 0 / 1), rgb(0 0 0 / 0));
 }
 .search-hero-row {
   display: flex;
@@ -1076,7 +1735,7 @@ useHead({
 }
 .search-title {
   margin: 0;
-  font-size: clamp(1.4rem, 3.5vw, 1.85rem);
+  font-size: clamp(1.25rem, 3vw, 1.625rem);
   line-height: 1.1;
   font-weight: 700;
   letter-spacing: calc(-0.02em * var(--tracking-scale));
@@ -1161,197 +1820,193 @@ useHead({
   gap: 0.65rem;
 }
 
-.filters-toggle {
-  margin-left: auto;
-  display: inline-flex;
-  align-items: center;
-  gap: 0.4rem;
-  padding: 0.35rem 0.65rem;
-  font-family: var(--font-mono);
-  font-size: 0.6563rem;
-  font-weight: 700;
-  letter-spacing: calc(0.16em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-  background: transparent;
-  border: 1px solid transparent;
-  border-radius: var(--radius-sm);
-  cursor: pointer;
-  transition: all var(--dur-2);
-}
-.filters-toggle:hover,
-.filters-toggle--on {
-  color: rgb(var(--fg-strong));
-  border-color: rgb(var(--line-default));
-  background: rgb(var(--bg-surface));
-}
-.filters-toggle-count {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  min-width: 1.1rem;
-  padding: 0 0.3rem;
-  font-size: 0.5938rem;
-  letter-spacing: 0;
-  color: rgb(var(--accent-fg));
-  background: rgb(var(--fg-strong));
-  border-radius: var(--radius-pill);
-}
-
-/* ─── Categories ─────────────────────────────────────────── */
-.cats {
+/* ─── Results header ─────────────────────────────────────── */
+/* ── La barre collante des filtres ──────────────────────────────────────── */
+.rbar {
+  position: sticky;
+  top: calc(var(--header-total) + 0.5rem);
+  z-index: 5;
   display: flex;
-  flex-direction: column;
-  gap: 0.65rem;
-}
-.cats-eyebrow {
-  margin: 0;
-  font-family: var(--font-mono);
-  font-size: 0.6563rem;
-  font-weight: 700;
-  letter-spacing: calc(0.22em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-subtle));
-}
-.cats-row {
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.5rem 1rem;
+  margin: 0 0 1rem;
+  padding: 0.5rem 0.75rem;
+  border: 1px solid rgb(var(--line-default) / 1);
+  border-radius: var(--radius-lg);
+  background: rgb(var(--bg-surface) / 0.96);
+  backdrop-filter: blur(10px);
+  box-shadow: 0 8px 24px -18px rgb(var(--shadow-color) / var(--shadow-strength));
+}
+.rbar-chips {
   display: flex;
   flex-wrap: wrap;
-  gap: 0.45rem;
-}
-.cats-row--sub {
-  padding-top: 0.35rem;
-  border-top: 1px dashed rgb(var(--line-default));
+  align-items: center;
+  gap: 0.4rem;
+  min-width: 0;
 }
-.cat-pill {
+.rbar-chip {
   display: inline-flex;
   align-items: center;
-  gap: 0.4rem;
-  padding: 0.4rem 0.85rem;
-  border: 1px solid rgb(var(--line-default));
+  gap: 0.35rem;
+  height: 1.85rem;
+  padding: 0 0.55rem 0 0.65rem;
   border-radius: var(--radius-pill);
-  background: rgb(var(--bg-surface));
-  color: rgb(var(--fg-muted));
-  font-family: var(--font-sans);
-  font-size: 0.78rem;
+  border: 1px solid rgb(var(--line-default) / 1);
+  background: rgb(var(--bg-inset) / 1);
+  color: rgb(var(--fg-strong) / 1);
+  font-size: 0.75rem;
   font-weight: 500;
-  cursor: pointer;
-  transition: all var(--dur-2);
+  line-height: 1;
   white-space: nowrap;
+  transition: border-color var(--dur-1) var(--ease-standard), background-color var(--dur-1) var(--ease-standard);
 }
-.cat-pill:hover {
-  border-color: rgb(var(--line-strong));
-  color: rgb(var(--fg-strong));
-  background: rgb(var(--bg-elevated));
-}
-.cat-pill--on {
-  background: rgb(var(--fg-strong));
-  color: rgb(var(--accent-fg));
-  border-color: rgb(var(--fg-strong));
-}
-.cat-pill--on:hover {
-  background: rgb(var(--fg-default));
-  color: rgb(var(--accent-fg));
+.rbar-chip:hover {
+  border-color: rgb(var(--danger) / 0.5);
+  background: rgb(var(--danger) / 0.08);
 }
-.cat-pill--sub {
-  font-size: 0.74rem;
-  padding: 0.32rem 0.7rem;
+.rbar-chip :deep(svg) {
+  width: 0.65rem;
+  height: 0.65rem;
+  color: rgb(var(--fg-muted) / 1);
 }
-
-/* ─── Filters panel ──────────────────────────────────────── */
-.filter-panel {
-  padding: 0.85rem 1rem 1rem;
-  background: rgb(var(--bg-surface));
-  border: 1px solid rgb(var(--line-default));
-  border-radius: var(--radius-sm);
+.rbar-chip:hover :deep(svg) {
+  color: rgb(var(--danger) / 1);
 }
-.filter-panel-head {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  margin-bottom: 0.5rem;
+.rbar-chip--token {
+  border-color: rgb(var(--accent-warm) / 0.35);
+  background: rgb(var(--accent-warm) / 0.1);
 }
-.filter-panel-clear {
+.rbar-chip-k {
   font-family: var(--font-mono);
   font-size: 0.625rem;
-  font-weight: 700;
-  letter-spacing: calc(0.16em * var(--tracking-scale));
   text-transform: uppercase;
-  color: rgb(var(--fg-muted));
-  background: transparent;
-  border: 0;
-  cursor: pointer;
+  letter-spacing: 0.08em;
+  color: rgb(var(--fg-muted) / 1);
 }
-.filter-panel-clear:hover {
-  color: rgb(var(--danger));
+.rbar-chip--token .rbar-chip-k {
+  color: rgb(var(--accent-warm-text) / 1);
 }
-.filter-panel-empty {
+.rbar-clear {
+  height: 1.85rem;
+  padding: 0 0.5rem;
   font-size: 0.75rem;
-  color: rgb(var(--fg-muted));
-  font-style: italic;
+  color: rgb(var(--fg-muted) / 1);
+  text-decoration: underline;
+  text-underline-offset: 3px;
+  text-decoration-color: rgb(var(--fg-faint) / 1);
+  border-radius: var(--radius-sm);
 }
-.filter-panel-tags {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 0.45rem;
+.rbar-clear:hover {
+  color: rgb(var(--fg-strong) / 1);
 }
-
-/* ─── Tag toggle (kept from previous design) ──────────── */
-.tag-toggle {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.4rem;
-  padding: 0.3rem 0.7rem;
-  border: 1px solid rgb(var(--line-default));
-  border-radius: var(--radius-pill);
-  background: rgb(var(--bg-elevated));
-  color: rgb(var(--fg-muted));
-  font-size: 0.6875rem;
-  font-weight: 500;
-  cursor: pointer;
-  transition: all var(--dur-1);
+.rbar-none {
+  font-size: 0.75rem;
+  color: rgb(var(--fg-faint) / 1);
 }
-.tag-toggle:hover {
-  color: rgb(var(--fg-strong));
-  border-color: rgb(var(--line-strong));
+.rbar-sum {
+  font-size: 0.75rem;
+  font-variant-numeric: tabular-nums;
+  color: rgb(var(--fg-muted) / 1);
 }
-.tag-toggle--active {
-  color: rgb(var(--fg-strong));
+.rbar-sum strong {
+  font-weight: 600;
+  color: rgb(var(--fg-strong) / 1);
 }
-
-/* ─── Results header ─────────────────────────────────────── */
-.results-head {
+.rbar-tools {
   display: flex;
   align-items: center;
-  justify-content: space-between;
-  gap: 1rem;
-  flex-wrap: wrap;
-  padding: 0.5rem 0.25rem;
-  border-bottom: 1px solid rgb(var(--line-default));
+  gap: 0.5rem;
+  margin-left: auto;
 }
-.results-stats {
+.rbar-sort {
   display: inline-flex;
   align-items: center;
-  gap: 0.65rem;
+  gap: 0.45rem;
+}
+.rbar-sort-k {
   font-family: var(--font-mono);
-  font-size: 0.6875rem;
-  letter-spacing: calc(0.06em * var(--tracking-scale));
-  color: rgb(var(--fg-muted));
+  font-size: 0.625rem;
   text-transform: uppercase;
+  letter-spacing: 0.1em;
+  color: rgb(var(--fg-muted) / 1);
 }
-.results-stat {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.35rem;
+.rbar-select {
+  height: 2rem;
+  padding: 0 1.75rem 0 0.6rem;
+  border: 1px solid rgb(var(--line-field) / 1);
+  border-radius: var(--radius-sm);
+  background-color: rgb(var(--bg-inset) / 1);
+  background-image: linear-gradient(45deg, transparent 50%, rgb(var(--fg-muted) / 1) 50%),
+    linear-gradient(135deg, rgb(var(--fg-muted) / 1) 50%, transparent 50%);
+  background-position: calc(100% - 0.95rem) 50%, calc(100% - 0.65rem) 50%;
+  background-size: 0.3rem 0.3rem, 0.3rem 0.3rem;
+  background-repeat: no-repeat;
+  appearance: none;
+  -webkit-appearance: none;
+  color: rgb(var(--fg-strong) / 1);
+  font-size: 0.75rem;
+  cursor: pointer;
 }
-.results-stat strong {
-  font-weight: 700;
-  color: rgb(var(--fg-strong));
+.rbar-ico,
+.rbar-density button {
+  display: inline-grid;
+  place-items: center;
+  width: 2rem;
+  height: 2rem;
+  border-radius: var(--radius-sm);
+  color: rgb(var(--fg-muted) / 1);
+  transition: background-color var(--dur-1) var(--ease-standard), color var(--dur-1) var(--ease-standard);
 }
-.results-stat-sep {
-  width: 4px;
-  height: 4px;
-  border-radius: var(--radius-pill);
-  background: rgb(var(--fg-faint));
+.rbar-ico :deep(svg),
+.rbar-density :deep(svg) {
+  width: 1rem;
+  height: 1rem;
+}
+.rbar-ico {
+  border: 1px solid rgb(var(--line-field) / 1);
+  background: rgb(var(--bg-inset) / 1);
+}
+.rbar-ico:hover,
+.rbar-density button:hover {
+  color: rgb(var(--fg-strong) / 1);
+  background: rgb(var(--bg-hover) / 1);
+}
+.rbar-density {
+  display: inline-flex;
+  padding: 0.15rem;
+  gap: 0.1rem;
+  border: 1px solid rgb(var(--line-field) / 1);
+  border-radius: var(--radius-sm);
+  background: rgb(var(--bg-inset) / 1);
+}
+.rbar-density button {
+  width: 1.75rem;
+  height: 1.6rem;
+  border-radius: calc(var(--radius-sm) - 2px);
+}
+.rbar-density button.is-on {
+  background: rgb(var(--bg-surface) / 1);
+  color: rgb(var(--accent-warm-text) / 1);
+  box-shadow: 0 1px 2px rgb(var(--shadow-color) / var(--shadow-strength));
+}
+@media (max-width: 40rem) {
+  .rbar {
+    position: static;
+    backdrop-filter: none;
+    background: rgb(var(--bg-surface) / 1);
+  }
+  .rbar-sort-k {
+    display: none;
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  .rbar-chip,
+  .rbar-ico,
+  .rbar-density button {
+    transition: none;
+  }
 }
 
 /* Where the rows draw from. Segmented rather than a checkbox: both states are
@@ -1389,54 +2044,7 @@ useHead({
   background: rgb(var(--bg-elevated));
 }
 
-/* ─── Loading / empty ───────────────────────────────────── */
-/* ── Save this search ─────────────────────────────────────────── */
-.save-search {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  margin-bottom: 1rem;
-}
-.save-search-link {
-  font-size: 0.75rem;
-  color: rgb(var(--fg-subtle));
-}
-.save-search-link:hover {
-  color: rgb(var(--accent));
-}
-
-/* ── Pinned block ────────────────────────────────────────────────
-   Set apart from the flow by a rule and an icon rather than by a tint: the
-   rows inside are ordinary rows and should read as such. */
-.pinned-block {
-  margin-bottom: 1.75rem;
-}
-.pinned-head {
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  margin-bottom: 0.6rem;
-}
-.pinned-icon {
-  width: 1rem;
-  height: 1rem;
-  color: rgb(var(--accent));
-}
-.pinned-title {
-  margin: 0;
-  font-size: 0.72rem;
-  letter-spacing: 0.14em;
-  text-transform: uppercase;
-  color: rgb(var(--fg-subtle));
-}
-.pinned-rule {
-  flex: 1;
-  height: 1px;
-  background: rgb(var(--line-default));
-}
-
-.results-loading,
-.results-empty {
+.results-loading {
   display: flex;
   flex-direction: column;
   align-items: center;
@@ -1454,30 +2062,11 @@ useHead({
 .results-loading p {
   margin: 0;
   font-family: var(--font-mono);
-  font-size: 0.6563rem;
+  font-size: 0.6875rem;
   letter-spacing: calc(0.18em * var(--tracking-scale));
   text-transform: uppercase;
   color: rgb(var(--fg-muted));
 }
-.results-empty-icon {
-  font-size: 2.25rem;
-  color: rgb(var(--fg-faint));
-}
-.results-empty h3 {
-  margin: 0;
-  font-size: 0.875rem;
-  font-weight: 700;
-  letter-spacing: calc(0.04em * var(--tracking-scale));
-  text-transform: uppercase;
-  color: rgb(var(--fg-strong));
-}
-.results-empty p {
-  margin: 0;
-  font-size: 0.75rem;
-  font-family: var(--font-mono);
-  color: rgb(var(--fg-muted));
-  max-width: 36ch;
-}
 
 /* ─── Bottom pagination ─────────────────────────────────── */
 .results-foot {
@@ -1502,12 +2091,6 @@ useHead({
   color: rgb(var(--fg-strong));
 }
 
-.trending {
-  display: flex;
-  flex-direction: column;
-  gap: 0.6rem;
-  margin-top: 0.5rem;
-}
 
 /* ─── media-id chip (kept from previous design) ────────── */
 .media-id-chip {
@@ -1579,47 +2162,6 @@ useHead({
   background: rgb(var(--fg-default) / 0.1);
 }
 
-/* ─── Transitions ─────────────────────────────────────── */
-.subs-enter-active,
-.subs-leave-active,
-.panel-enter-active,
-.panel-leave-active {
-  transition: max-height var(--dur-4) ease, opacity var(--dur-3) ease, padding var(--dur-3) ease,
-    margin var(--dur-3) ease;
-  overflow: hidden;
-}
-.subs-enter-from,
-.subs-leave-to {
-  max-height: 0;
-  opacity: 0;
-  padding-top: 0;
-  margin-top: 0;
-}
-.subs-enter-to,
-.subs-leave-from {
-  max-height: 200px;
-  opacity: 1;
-}
-.panel-enter-from,
-.panel-leave-to {
-  max-height: 0;
-  opacity: 0;
-}
-.panel-enter-to,
-.panel-leave-from {
-  max-height: 600px;
-  opacity: 1;
-}
-.hint-enter-active,
-.hint-leave-active {
-  transition: opacity var(--dur-3) ease, transform var(--dur-3) ease;
-}
-.hint-enter-from,
-.hint-leave-to {
-  opacity: 0;
-  transform: translateY(-4px);
-}
-
 /* ─── Mobile reflow ─────────────────────────────────────── */
 @media (max-width: 640px) {
   .search-hero-row {
@@ -1640,20 +2182,468 @@ useHead({
     flex: 1;
     justify-content: center;
   }
-  /* Cat row scrolls horizontally on phones so chips stay readable. */
-  .cats-row {
-    flex-wrap: nowrap;
-    overflow-x: auto;
-    margin-inline: -1rem;
-    padding-inline: 1rem;
-    scrollbar-width: none;
+}
+
+/* ── Rail + résultats ────────────────────────────────────────────────────── */
+.layout {
+  display: grid;
+  grid-template-columns: 15.5rem minmax(0, 1fr);
+  gap: 1.75rem;
+  align-items: start;
+}
+.rail {
+  position: sticky;
+  top: calc(var(--header-total) + 1rem);
+  max-height: calc(100vh - var(--header-total) - 1.5rem);
+  overflow-y: auto;
+  scrollbar-width: thin;
+  padding-right: 0.25rem;
+}
+.results {
+  min-width: 0;
+  container-type: inline-size;
+}
+.results > .rbar {
+  margin-top: 0;
+}
+@media (max-width: 68.75rem) {
+  .layout {
+    grid-template-columns: 1fr;
+    gap: 1rem;
+  }
+  .rail {
+    display: none;
+    position: static;
+    max-height: none;
+    padding: 0.9rem;
+    border: 1px solid rgb(var(--line-default) / 1);
+    border-radius: var(--radius-lg);
+    background: rgb(var(--bg-surface) / 1);
+  }
+  .rail--open {
+    display: block;
+  }
+  .rail--open :deep(.cf) {
+    grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr));
+    gap: 1rem 1.5rem;
+  }
+}
+
+/* ── L'état vide qui propose ─────────────────────────────────────────────── */
+.empty {
+  position: relative;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 1rem 2rem;
+  align-items: center;
+  margin-top: 1rem;
+  padding: 1.5rem 1.5rem 1.4rem;
+  border: 1px dashed rgb(var(--line-strong) / 1);
+  border-radius: var(--radius-xl);
+  background: rgb(var(--bg-surface) / 0.6);
+}
+.empty-title {
+  margin: 0 0 0.3rem;
+  font-family: var(--font-display);
+  font-style: italic;
+  font-weight: 500;
+  font-size: 1.25rem;
+  line-height: 1.1;
+  color: rgb(var(--fg-strong) / 1);
+  overflow-wrap: anywhere;
+}
+.empty-hint {
+  margin: 0;
+  max-width: 60ch;
+  color: rgb(var(--fg-muted) / 1);
+}
+.empty-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  margin: 0.8rem 0 0;
+  padding: 0;
+  list-style: none;
+}
+.empty-rel {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.4rem;
+  min-height: 1.85rem;
+  padding: 0 0.65rem;
+  border: 1px solid rgb(var(--line-strong) / 1);
+  border-radius: var(--radius-pill);
+  font-size: 0.75rem;
+  font-weight: 600;
+  color: rgb(var(--fg-default) / 1);
+  transition: border-color var(--dur-1) var(--ease-standard), background-color var(--dur-1) var(--ease-standard);
+}
+.empty-rel:hover {
+  border-color: rgb(var(--fg-muted) / 1);
+  background: rgb(var(--bg-hover) / 1);
+}
+.empty-rel b {
+  font-family: var(--font-mono);
+  font-size: 0.6875rem;
+  color: rgb(var(--online) / 1);
+}
+.empty-act {
+  display: grid;
+  gap: 0.5rem;
+}
+.empty-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5rem;
+  min-height: 2.5rem;
+  padding: 0 1rem;
+  border-radius: var(--radius-pill);
+  font-size: 0.8125rem;
+  font-weight: 700;
+  text-decoration: none;
+  white-space: nowrap;
+  transition: transform var(--dur-1) var(--ease-standard), opacity var(--dur-1) var(--ease-standard);
+}
+.empty-btn :deep(svg) {
+  width: 0.9rem;
+  height: 0.9rem;
+}
+.empty-btn:active {
+  transform: scale(0.98);
+}
+.empty-btn--primary {
+  background: rgb(var(--fg-default) / 1);
+  color: rgb(var(--bg-base) / 1);
+}
+.empty-btn--gold {
+  border: 1px solid rgb(var(--accent-warm) / 0.6);
+  background: rgb(var(--accent-warm) / 0.12);
+  color: rgb(var(--accent-warm-text) / 1);
+}
+.empty-btn:disabled {
+  opacity: 0.6;
+  cursor: progress;
+}
+@media (max-width: 40rem) {
+  .empty {
+    grid-template-columns: 1fr;
+  }
+}
+
+/* ── La feuille de filtres et son bouton, écran étroit seulement ─────────── */
+.sheet-head,
+.sheet-apply,
+.sheet-backdrop,
+.m-fab {
+  display: none;
+}
+@media (max-width: 68.75rem) {
+  .m-fab {
+    position: fixed;
+    right: 1rem;
+    bottom: calc(1rem + env(safe-area-inset-bottom, 0px));
+    z-index: 55;
+    display: inline-flex;
+    align-items: center;
+    gap: 0.5rem;
+    min-height: 2.75rem;
+    padding: 0 1rem;
+    border-radius: var(--radius-pill);
+    background: rgb(var(--fg-default) / 1);
+    color: rgb(var(--bg-base) / 1);
+    font-size: 0.8125rem;
+    font-weight: 700;
+    box-shadow: 0 12px 24px -8px rgb(var(--shadow-color) / 0.6);
+  }
+  .m-fab :deep(svg) {
+    width: 0.9rem;
+    height: 0.9rem;
+  }
+  .m-fab-n {
+    padding: 0 0.4rem;
+    border-radius: var(--radius-pill);
+    background: rgb(var(--accent-warm) / 1);
+    color: rgb(var(--accent-warm-fg) / 1);
+    font-family: var(--font-mono);
+    font-size: 0.625rem;
+    font-weight: 800;
+    line-height: 1.2rem;
+  }
+  .sheet-backdrop {
+    display: block;
+    position: fixed;
+    inset: 0;
+    z-index: 59;
+    background: rgb(var(--bg-base) / 0.6);
+    backdrop-filter: blur(2px);
+  }
+  .rail--open {
+    position: fixed;
+    inset: auto 0 0 0;
+    z-index: 60;
+    max-height: 82dvh;
+    overflow-y: auto;
+    padding: 0.75rem 0.9rem calc(0.75rem + env(safe-area-inset-bottom, 0px));
+    border: 0;
+    border-top: 1px solid rgb(var(--line-strong) / 1);
+    border-radius: 20px 20px 0 0;
+    background: rgb(var(--bg-elevated) / 1);
+    box-shadow: 0 -20px 40px -12px rgb(var(--shadow-color) / var(--shadow-strength));
+    animation: sheet-in var(--dur-4) var(--ease-emphasis) both;
+  }
+  @keyframes sheet-in {
+    from {
+      transform: translateY(1.5rem);
+      opacity: 0;
+    }
+  }
+  .rail--open::before {
+    content: '';
+    display: block;
+    width: 2.5rem;
+    height: 4px;
+    margin: 0 auto 0.6rem;
+    border-radius: 2px;
+    background: rgb(var(--line-strong) / 1);
+  }
+  .sheet-head {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    margin-bottom: 0.6rem;
+  }
+  .sheet-title {
+    margin: 0 auto 0 0;
+    font-family: var(--font-display);
+    font-style: italic;
+    font-weight: 500;
+    font-size: 1.1rem;
+    outline: none;
+  }
+  .sheet-clear {
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: rgb(var(--fg-muted) / 1);
+    text-decoration: underline;
+    text-underline-offset: 3px;
+  }
+  .sheet-close {
+    display: inline-grid;
+    place-items: center;
+    width: 2.25rem;
+    height: 2.25rem;
+    border-radius: 50%;
+    color: rgb(var(--fg-muted) / 1);
+  }
+  .sheet-close:hover {
+    background: rgb(var(--bg-hover) / 1);
+    color: rgb(var(--fg-strong) / 1);
+  }
+  .sheet-close :deep(svg) {
+    width: 0.9rem;
+    height: 0.9rem;
+  }
+  .sheet-apply {
+    position: sticky;
+    bottom: 0;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    width: 100%;
+    min-height: 2.75rem;
+    margin-top: 0.75rem;
+    border-radius: var(--radius-pill);
+    background: rgb(var(--fg-default) / 1);
+    color: rgb(var(--bg-base) / 1);
+    font-size: 0.8125rem;
+    font-weight: 700;
+    box-shadow: 0 -8px 16px -8px rgb(var(--bg-elevated) / 1);
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  .rail--open {
+    animation: none;
+  }
+  .empty-rel,
+  .empty-btn {
+    transition: none;
+  }
+}
+
+/* ── Revue : actualisation sans clignotement, feuille et cibles tactiles ─── */
+.is-refreshing > :not(.results-loading) {
+  opacity: 0.6;
+  transition: opacity var(--dur-2) var(--ease-standard);
+}
+@media (min-width: 68.8rem) {
+  /* Le titre « Filtres » reste dans l'arbre d'accessibilité (h1 → h2 → h3) ;
+     seuls ses boutons disparaissent : ils n'ont de sens que dans la feuille. */
+  .sheet-head {
+    display: block;
   }
-  .cats-row::-webkit-scrollbar {
+  .sheet-head .rail-title {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    margin: -1px;
+    padding: 0;
+    overflow: hidden;
+    clip: rect(0 0 0 0);
+    white-space: nowrap;
+  }
+  .sheet-head .sheet-clear,
+  .sheet-head .sheet-close {
     display: none;
   }
-  .filters-toggle {
-    margin-left: 0;
+}
+@media (max-width: 68.75rem) {
+  /* Le bouton flottant ne doit pas couvrir la dernière ligne ni le pied de page. */
+  .layout {
+    margin-bottom: 4.5rem;
+  }
+}
+@media (pointer: coarse) {
+  .rbar-density button {
+    width: 2.25rem;
+    height: 2.1rem;
+  }
+  .rbar-ico,
+  .rbar-select {
+    height: 2.5rem;
+  }
+  .rbar-chip {
+    height: 2.25rem;
   }
+  .sheet-clear {
+    min-height: 2.25rem;
+    padding: 0 0.5rem;
+  }
+}
+
+.rbar-defaults {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.3rem;
+  text-decoration: none;
+}
+.rbar-defaults :deep(svg) {
+  width: 0.75rem;
+  height: 0.75rem;
+}
+.rbar-defaults--on {
+  color: rgb(var(--accent-warm-text) / 1);
+}
+.empty-dym {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.4rem;
+  margin: 0.8rem 0 0;
+  font-size: 0.8125rem;
+  color: rgb(var(--fg-muted) / 1);
+}
+.empty-rel--dym {
+  color: rgb(var(--accent-warm-text) / 1);
+  border-color: rgb(var(--accent-warm) / 0.5);
 }
 
+/* ── Squelettes : la forme des cartes à venir, en gris qui respire ────────── */
+.results-loading {
+  display: grid;
+  gap: 0.55rem;
+  padding: 0;
+  border: 0;
+  background: transparent;
+}
+.skel {
+  display: grid;
+  grid-template-columns: 56px minmax(0, 1fr);
+  grid-template-rows: auto auto;
+  gap: 0.4rem 0.9rem;
+  align-items: center;
+  padding: 0.65rem 0.9rem 0.65rem 1rem;
+  border: 1px solid rgb(var(--line-default) / 1);
+  border-radius: var(--radius-xl);
+  background: rgb(var(--bg-surface) / 1);
+  animation: skel-in var(--dur-3) var(--ease-standard) both;
+  animation-delay: calc(var(--i, 0) * 60ms);
+}
+.skel > * {
+  border-radius: var(--radius-xs);
+  background: linear-gradient(90deg, rgb(var(--bg-inset) / 1), rgb(var(--bg-hover) / 1), rgb(var(--bg-inset) / 1));
+  background-size: 200% 100%;
+  animation: skel-shimmer 1.4s linear infinite;
+}
+.skel-pst {
+  grid-row: 1 / 3;
+  width: 56px;
+  height: 84px;
+  border-radius: var(--radius-sm);
+}
+.skel-l--t {
+  height: 1.1rem;
+  width: 55%;
+  align-self: end;
+}
+.skel-l--m {
+  height: 0.7rem;
+  width: 35%;
+  align-self: start;
+}
+@keyframes skel-in {
+  from {
+    opacity: 0;
+  }
+}
+@keyframes skel-shimmer {
+  to {
+    background-position: -200% 0;
+  }
+}
+/* ── La barre collante : une ombre quand elle colle, rien posée ─────────────── */
+.rbar-sentinel {
+  height: 1px;
+  margin-top: -1px;
+}
+.rbar {
+  box-shadow: none;
+  transition: box-shadow var(--dur-2) var(--ease-standard);
+}
+.rbar--stuck {
+  box-shadow: 0 10px 24px -16px rgb(var(--shadow-color) / var(--shadow-strength));
+}
+/* ── Les outils de la feuille : visibles sur écran étroit seulement ────────── */
+.sheet-tools {
+  display: none;
+}
+@media (max-width: 68.75rem) {
+  .sheet-tools {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    margin-bottom: 0.75rem;
+    padding-bottom: 0.75rem;
+    border-bottom: 1px solid rgb(var(--line-default) / 1);
+  }
+  .sheet-tools .rbar-sort {
+    flex: 1;
+    min-width: 0;
+  }
+  .sheet-tools .rbar-select {
+    width: 100%;
+  }
+  .rbar > .rbar-tools {
+    display: none;
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  .skel,
+  .skel > * {
+    animation: none;
+  }
+  .rbar {
+    transition: none;
+  }
+}
 </style>
diff --git a/apps/web/app/pages/users/[id].vue b/apps/web/app/pages/users/[id].vue
index 4d23babd..5a2fa346 100644
--- a/apps/web/app/pages/users/[id].vue
+++ b/apps/web/app/pages/users/[id].vue
@@ -725,9 +725,9 @@ useHead({
      exactly 100 vw wide — no fractional bleed that could trigger
      a stray right-scroll. */
   top: -2rem;
-  left: 50%;
-  width: 100vw;
-  margin-left: -50vw;
+  left: 0;
+  right: 0;
+  overflow: hidden;
   height: 70vh;
   z-index: -1;
   overflow: hidden;
@@ -790,6 +790,8 @@ useHead({
 
 /* ── Back link ────────────────────────────────────────────────── */
 .profile-back {
+  /* WCAG 2.5.8 : 24 px de cible au minimum. Mesuré à 15 px avant. */
+  min-height: 1.5rem;
   display: inline-flex;
   align-items: center;
   gap: 0.5rem;
@@ -1433,7 +1435,7 @@ useHead({
   margin: 0;
   padding: 0;
   display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 160px), 1fr));
   gap: 0.65rem;
 }
 .stat {
diff --git a/apps/web/app/utils/catalogueFacets.ts b/apps/web/app/utils/catalogueFacets.ts
new file mode 100644
index 00000000..80022590
--- /dev/null
+++ b/apps/web/app/utils/catalogueFacets.ts
@@ -0,0 +1,83 @@
+/**
+ * Les types du rail de facettes, hors du composant : un `<script setup>` ne
+ * peut pas exporter de valeur, et la page a besoin de la liste des options.
+ */
+export interface FacetsResponse {
+  total: number;
+  categories: Array<{ id: string; count: number }>;
+  tags: Array<{ slug: string; name: string; count: number }>;
+  /** Les mêmes comptes, le groupe i de `tagGroups` retiré : pour la famille qui l'a posé. */
+  tagsByGroup?: Record<string, Array<{ slug: string; name: string; count: number }>>;
+  years: Array<{ year: number; count: number }>;
+  options: { withSeeders: number; freeleech: number; notTaken: number; superseded: number; favorites?: number; today?: number };
+  /** Dernière passe du collecteur d'essaims (`torrent_stats`), ISO ou null. */
+  statsAt?: string | null;
+  /** Quand rien ne sort : le compte sans chacun des critères posés. */
+  dropOne?: Array<{ key: string; count: number }> | null;
+  /** Le catalogue entier, visible par ce membre — quand rien ne sort. */
+  catalogue?: number | null;
+  /** Des titres d'œuvres proches du texte, par trigrammes — quand rien ne sort. */
+  didYouMean?: Array<{ source: string; externalId: string; title: string }> | null;
+}
+
+export interface FacetCategory {
+  id: string;
+  name: string;
+  slug: string;
+  parentId: string | null;
+  subcategories?: FacetCategory[];
+}
+
+/** Les quatre options du rail, dans l'ordre d'affichage ; c'est aussi la valeur du paramètre `o`. */
+export type OptionKey = 'seeded' | 'today' | 'free' | 'untaken' | 'current' | 'favorites';
+export const OPTION_KEYS: readonly OptionKey[] = ['seeded', 'today', 'free', 'untaken', 'current', 'favorites'];
+
+/** Les facettes que le rail peut montrer ; l'opérateur choisit lesquelles. */
+export const FACET_KEYS = ['category', 'resolution', 'source', 'codec', 'language', 'hdr', 'audio', 'year', 'options'] as const;
+export type FacetKey = (typeof FACET_KEYS)[number];
+
+/* ── La logique du rail, hors composant pour être testée ────────────────── */
+export interface CategoryRow {
+  id: string;
+  name: string;
+  count: number;
+  kids: Array<{ id: string; name: string; count: number }>;
+}
+
+/**
+ * Les catégories du rail : un parent compte ses enfants ; on ne montre que ce
+ * qui a des releases sous la recherche courante, plus ce qui est coché ; les
+ * plus fournies d'abord.
+ */
+export function categoryRows(
+  categories: FacetCategory[],
+  counts: Array<{ id: string; count: number }>,
+  selected: string,
+): CategoryRow[] {
+  const byId = new Map(counts.map((c) => [c.id, c.count]));
+  return categories
+    .map((p) => {
+      const kids = (p.subcategories ?? [])
+        .map((s) => ({ id: s.id, name: s.name, count: byId.get(s.id) ?? 0 }))
+        .filter((k) => k.count > 0 || k.id === selected)
+        .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+      const count = (byId.get(p.id) ?? 0) + kids.reduce((acc, k) => acc + k.count, 0);
+      return { id: p.id, name: p.name, count, kids };
+    })
+    .filter((p) => p.count > 0 || p.id === selected || p.kids.some((k) => k.id === selected))
+    .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+}
+
+/**
+ * Les lignes d'une famille d'étiquettes : celles de `tagsByGroup[i]` quand la
+ * famille a posé le groupe i (comptée sans elle-même), les comptes stricts
+ * sinon — puis filtrées à la famille et triées par compte.
+ */
+export function familyRows(
+  facets: Pick<FacetsResponse, 'tags' | 'tagsByGroup'>,
+  groupIndex: number,
+  belongs: (slug: string) => boolean,
+): Array<{ slug: string; name: string; count: number }> {
+  const source = (groupIndex >= 0 ? facets.tagsByGroup?.[String(groupIndex)] : undefined) ?? facets.tags;
+  return source.filter((tg) => belongs(tg.slug)).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+}
diff --git a/apps/web/app/utils/chipTagOverlap.ts b/apps/web/app/utils/chipTagOverlap.ts
new file mode 100644
index 00000000..d332dcb4
--- /dev/null
+++ b/apps/web/app/utils/chipTagOverlap.ts
@@ -0,0 +1,136 @@
+import { releaseChips, type ReleaseChips } from '~/utils/releaseChips';
+
+/**
+ * Les tags qu'aucune pastille de qualité ne dit déjà.
+ *
+ * # Pourquoi ce fichier existe
+ *
+ * La page de détail montrait deux rangées qui disent la même chose : les
+ * pastilles, ANALYSÉES depuis le nom de release, et les tags, dont l'immense
+ * majorité est INFÉRÉE du même nom à l'upload (`inferReleaseTags` le dit
+ * lui-même : « resolution, codec, source, audio, language, HDR, extras »).
+ * Deux rendus de la même extraction, l'un dérivé à l'affichage, l'autre
+ * persisté en base.
+ *
+ * Mesuré sur les 49 torrents du catalogue de test : **149 tags, dont 107
+ * (72 %) mot pour mot ce qu'une pastille disait déjà**. Et sur les 42
+ * survivants, la plupart étaient le même fait sous un autre nom — `x264` neuf
+ * fois pendant que la pastille affichait `AVC`, `VF`/`VFF`/`MULTI` six fois
+ * pendant qu'elle affichait la langue.
+ *
+ * # Pourquoi une table d'équivalences, et pourquoi elle est courte
+ *
+ * `x264` et `AVC` sont le même fait : l'un est l'encodeur, l'autre la norme
+ * qu'il produit. Les confondre est vrai. En revanche `MULTI` et `VOSTFR` ne
+ * sont PAS la même chose — plusieurs pistes audio d'un côté, une piste
+ * sous-titrée de l'autre — et la tentation de les rapprocher parce qu'ils
+ * occupent la même fente ferait disparaître une information réelle.
+ *
+ * La règle retenue est donc conservatrice : dans le doute, on GARDE le tag.
+ * Un tag de trop est du bruit ; un tag manquant est une information perdue.
+ */
+
+/**
+ * Ce qu'un tag désigne quand la pastille l'appelle autrement.
+ *
+ * Uniquement des synonymes STRICTS — l'encodeur et sa norme. Rien qui relève
+ * du jugement.
+ */
+const ALIASES: Record<string, string> = {
+  x264: 'avc',
+  h264: 'avc',
+  avc1: 'avc',
+  x265: 'hevc',
+  h265: 'hevc',
+  hvc1: 'hevc',
+};
+
+const norm = (s: string) => s.toLowerCase().replace(/[^a-z0-9.]/g, '');
+
+/**
+ * Les « atomes » que les pastilles affichent.
+ *
+ * Une pastille peut porter deux valeurs dans une seule fente — `AAC 2.0` pour
+ * l'audio, `MULTI.VFF` pour la langue. Comparer la chaîne entière laisserait
+ * passer un tag `AAC` alors que la pastille le dit. On découpe donc sur
+ * l'espace, et sur le point POUR LA LANGUE seulement : découper `2.0` sur le
+ * point donnerait les atomes `2` et `0`, qui rendraient redondant n'importe
+ * quel tag nommé « 2 ».
+ */
+export function chipAtoms(chips: ReleaseChips): Set<string> {
+  const out = new Set<string>();
+  const add = (v: string | null | undefined) => {
+    if (!v) return;
+    out.add(norm(v));
+    for (const part of v.split(/\s+/)) if (part) out.add(norm(part));
+  };
+  add(chips.resolution);
+  add(chips.source);
+  add(chips.audio);
+  add(chips.codec);
+  add(chips.hdr);
+  add(chips.platform);
+  add(chips.format);
+  for (const f of chips.flags) add(f);
+  if (chips.language) {
+    out.add(norm(chips.language));
+    for (const part of chips.language.split(/[.\s]+/)) if (part) out.add(norm(part));
+  }
+  return out;
+}
+
+/** Un tag, tel que la charge du torrent le porte. */
+export interface TorrentTag {
+  id?: string;
+  name: string;
+  slug?: string;
+  color?: string | null;
+}
+
+/**
+ * Filtre une liste de tags contre les pastilles d'un nom de release.
+ *
+ * Renvoie les tags à AFFICHER — ceux qui apportent quelque chose. Sans nom de
+ * release, ou si l'analyse ne donne rien, tous les tags reviennent : ne rien
+ * savoir n'est pas une raison de cacher.
+ */
+export function tagsBeyondChips<T extends TorrentTag>(
+  releaseName: string | null | undefined,
+  tags: readonly T[] | null | undefined,
+): T[] {
+  if (!tags?.length) return [];
+  if (!releaseName) return [...tags];
+  const atoms = chipAtoms(releaseChips(releaseName));
+  if (!atoms.size) return [...tags];
+  return tags.filter((t) => {
+    const n = norm(t.name);
+    if (atoms.has(n)) return false;
+    const alias = ALIASES[n];
+    return !(alias && atoms.has(alias));
+  });
+}
+
+/**
+ * Le tag qui correspond à une valeur de pastille, s'il y en a un.
+ *
+ * C'est ce qui rend une pastille CLIQUABLE : les tags portent des slugs
+ * exploitables (`web-dl`, `x264`, `2-0`) et sont la seule chose que la rangée
+ * du bas apportait vraiment — un lien vers le catalogue filtré. La pastille
+ * reprend cette fonction ; sans tag correspondant elle reste inerte, plutôt
+ * que de fabriquer un lien vers un filtre qui ne trouverait rien.
+ */
+export function tagForChip<T extends TorrentTag>(
+  value: string | null | undefined,
+  tags: readonly T[] | null | undefined,
+): T | null {
+  if (!value || !tags?.length) return null;
+  const wanted = new Set<string>([norm(value)]);
+  for (const part of value.split(/[.\s]+/)) if (part) wanted.add(norm(part));
+  for (const t of tags) {
+    const n = norm(t.name);
+    if (wanted.has(n)) return t;
+    const alias = ALIASES[n];
+    if (alias && wanted.has(alias)) return t;
+  }
+  return null;
+}
diff --git a/apps/web/app/utils/duration.ts b/apps/web/app/utils/duration.ts
new file mode 100644
index 00000000..c1b6023a
--- /dev/null
+++ b/apps/web/app/utils/duration.ts
@@ -0,0 +1,80 @@
+/**
+ * Des durées lisibles, dans la langue du lecteur, sans une seule chaîne à
+ * traduire.
+ *
+ * `format.ts` sait dire « il y a 3 jours » et « dans 3 jours » — un instant
+ * relatif à maintenant. Il ne sait pas dire une durée ABSOLUE : « 72 h »,
+ * « 2 h 46 ». La page de détail en demande deux, et ni l'une ni l'autre n'est
+ * un âge : le temps de seed qu'un membre doit encore, et la durée d'un film.
+ *
+ * `Intl.NumberFormat` avec `style: 'unit'` plutôt qu'un gabarit i18n par
+ * unité : l'unité, son abréviation et sa place par rapport au nombre sont des
+ * données de locale, pas des décisions de produit. « 2h 46m » en anglais et
+ * « 2 h 46 min » en français sortent de la même ligne de code, et une
+ * troisième langue n'aura rien à ajouter.
+ */
+
+/**
+ * L'abréviation d'une unité, dans la langue demandée.
+ *
+ * `short` et non `narrow` : `narrow` colle le nombre à l'unité — « 61h »,
+ * « 2h 46min » — alors que la typographie française demande une espace, et
+ * c'est « 61 h » que porte la maquette de référence. `short` la met, et met
+ * une espace insécable étroite (U+202F), donc la valeur ne peut pas se couper
+ * en fin de ligne. Le coût est deux caractères en anglais (« 61 hr »).
+ */
+function unit(
+  value: number,
+  u: 'day' | 'hour' | 'minute',
+  locale: string,
+): string {
+  return new Intl.NumberFormat(locale, {
+    style: 'unit',
+    unit: u,
+    unitDisplay: 'short',
+    maximumFractionDigits: 0,
+  }).format(value);
+}
+
+/** Quatre jours. Au-delà, on passe aux jours ; en dessous, on reste en heures. */
+const DAYS_THRESHOLD = 96 * 3600;
+
+/**
+ * Une durée en secondes, telle qu'on l'annonce sur la page.
+ *
+ * Volontairement en HEURES tant que la valeur reste sous quatre jours, parce
+ * que l'obligation de seed du site se compte en heures (72 h) et que
+ * « 2 j 13 h » demande une soustraction mentale que « 61 h » ne demande pas.
+ * Au-delà, la lecture s'inverse et les jours reprennent la main.
+ */
+export function formatDurationSeconds(seconds: number, locale: string): string {
+  const total = Math.max(0, Math.round(seconds));
+  if (total < 3600) return unit(Math.round(total / 60), 'minute', locale);
+  if (total < DAYS_THRESHOLD) return unit(Math.round(total / 3600), 'hour', locale);
+  let days = Math.floor(total / 86400);
+  let hours = Math.round((total % 86400) / 3600);
+  // 4 j 23 h 50 arrondit à « 24 h » : c'est un jour de plus, pas une 24ᵉ heure.
+  if (hours === 24) {
+    days += 1;
+    hours = 0;
+  }
+  if (hours === 0) return unit(days, 'day', locale);
+  return `${unit(days, 'day', locale)} ${unit(hours, 'hour', locale)}`;
+}
+
+/**
+ * La durée d'une œuvre, en minutes — ce que renvoie chaque fournisseur de
+ * métadonnées.
+ *
+ * Ne PAS passer par `formatDurationSeconds` : elle arrondit à l'heure sous
+ * quatre jours, et un film de 166 minutes y devient « 3h ». La minute est
+ * précisément ce qui distingue deux montages du même film.
+ */
+export function formatRuntimeMinutes(minutes: number, locale: string): string {
+  const total = Math.max(0, Math.round(minutes));
+  if (total < 60) return unit(total, 'minute', locale);
+  const hours = Math.floor(total / 60);
+  const rest = total % 60;
+  if (rest === 0) return unit(hours, 'hour', locale);
+  return `${unit(hours, 'hour', locale)} ${unit(rest, 'minute', locale)}`;
+}
diff --git a/apps/web/app/utils/releaseChips.ts b/apps/web/app/utils/releaseChips.ts
index f5e542e4..24a05d84 100644
--- a/apps/web/app/utils/releaseChips.ts
+++ b/apps/web/app/utils/releaseChips.ts
@@ -50,10 +50,24 @@ const SOURCES = [
   'REMUX', 'BluRay', 'UHD', 'WEB-DL', 'WEBRip', 'WEB',
   'HDRip', 'HDTV', 'DVDRip', 'DVD',
 ];
+/*
+ * Le FORMAT audio, et les canaux, séparément.
+ *
+ * `2.0` était dans la même liste, avant `AAC` : sur
+ * `…WEB-DL.AAC.2.0.H.264…` le parseur sort bien `["2.0", "AAC"]`, mais le
+ * premier trouvé prenait la place et le codec disparaissait. Mesuré sur le
+ * catalogue : `AAC` survivait onze fois dans la rangée de tags parce qu'aucune
+ * pastille ne le disait — c'était la seule information que les tags
+ * apportaient vraiment.
+ *
+ * Les entrées composées (`DDP5.1`, `EAC3 5.1`) portent déjà les deux ; elles
+ * restent dans la liste des formats et ne se voient rien ajouter.
+ */
 const AUDIO = [
   'Atmos', 'TrueHD', 'DTS-HD', 'DTS', 'EAC3 5.1', 'DDP5.1', 'DD5.1',
-  'AC3 5.1', 'FLAC', '2.0', 'AAC', 'MP3',
+  'AC3 5.1', 'FLAC', 'AAC', 'MP3',
 ];
+const AUDIO_CHANNELS = ['7.1', '5.1', '2.0'];
 const CODECS = ['HEVC', 'AVC', 'AV1'];
 const HDR = ['Dolby Vision', 'HDR10+', 'HDR10', 'HDR', '10bit', 'SDR'];
 const PLATFORMS = [
@@ -78,6 +92,22 @@ function pick(tags: Set<string>, order: string[]): string | null {
   return null;
 }
 
+/**
+ * Le format et les canaux dans une seule fente — `AAC 2.0`.
+ *
+ * Une fente, pas deux : c'est une seule facette, l'audio, dite sur deux
+ * dimensions. Le même parti que `language`, qui joint déjà `MULTI.VFF`.
+ * Un format qui porte déjà ses canaux (`DDP5.1`) ne se voit rien ajouter, et
+ * des canaux sans format se suffisent à eux-mêmes.
+ */
+function audioChip(tags: Set<string>): string | null {
+  const format = pick(tags, AUDIO);
+  const channels = pick(tags, AUDIO_CHANNELS);
+  if (!format) return channels;
+  if (!channels || /\d\.\d/.test(format)) return format;
+  return `${format} ${channels}`;
+}
+
 export function releaseChips(name: string): ReleaseChips {
   let tags: string[] = [];
   try {
@@ -96,7 +126,7 @@ export function releaseChips(name: string): ReleaseChips {
     language: languages.length ? languages.slice(0, 2).join('.') : null,
     resolution: pick(set, RESOLUTIONS),
     source: pick(set, SOURCES),
-    audio: pick(set, AUDIO),
+    audio: audioChip(set),
     codec: pick(set, CODECS),
     hdr: pick(set, HDR),
     platform: pick(set, PLATFORMS),
diff --git a/apps/web/app/utils/releaseVersions.ts b/apps/web/app/utils/releaseVersions.ts
new file mode 100644
index 00000000..8173314d
--- /dev/null
+++ b/apps/web/app/utils/releaseVersions.ts
@@ -0,0 +1,43 @@
+/**
+ * Regrouper les versions d'un même contenu.
+ *
+ * Deux encodages du même épisode de la même œuvre sont deux lignes ; dans la
+ * vue Releases, la première (dans l'ordre du tri — donc la mieux classée) fait
+ * la tête, les autres se replient derrière « n autres versions ». Une release
+ * sans œuvre connue ne se regroupe jamais : sans identifiant, deux noms
+ * proches ne prouvent rien.
+ */
+export interface VersionRowLike {
+  id: string;
+  season?: number | null;
+  episode?: number | null;
+  work?: { source?: string; id?: string } | null;
+}
+
+export interface VersionGroup<T> {
+  key: string;
+  lead: T;
+  others: T[];
+}
+
+export function versionKey(row: VersionRowLike): string | null {
+  if (!row.work?.id) return null;
+  return `${row.work.source ?? ''}:${row.work.id}|${row.season ?? ''}|${row.episode ?? ''}`;
+}
+
+export function groupVersions<T extends VersionRowLike>(rows: T[]): VersionGroup<T>[] {
+  const byKey = new Map<string, VersionGroup<T>>();
+  const out: VersionGroup<T>[] = [];
+  for (const row of rows) {
+    const key = versionKey(row) ?? `solo:${row.id}`;
+    const existing = byKey.get(key);
+    if (existing) {
+      existing.others.push(row);
+      continue;
+    }
+    const group: VersionGroup<T> = { key, lead: row, others: [] };
+    byKey.set(key, group);
+    out.push(group);
+  }
+  return out;
+}
diff --git a/apps/web/app/utils/savedSearchLink.ts b/apps/web/app/utils/savedSearchLink.ts
index a63d7f6c..10e24fb7 100644
--- a/apps/web/app/utils/savedSearchLink.ts
+++ b/apps/web/app/utils/savedSearchLink.ts
@@ -35,6 +35,11 @@ export interface SavedSearchCriteria {
   imdbId?: string | null;
   tmdbId?: string | null;
   tvdbId?: string | null;
+  /** Les critères de la barre : `hevc,x265;1080p` → `tk`, saison/épisode → `se`/`ep`, année → `y`. */
+  tagGroups?: string | null;
+  season?: number | null;
+  episode?: number | null;
+  year?: number | null;
 }
 
 export function savedSearchLink(s: SavedSearchCriteria): string {
@@ -45,6 +50,22 @@ export function savedSearchLink(s: SavedSearchCriteria): string {
   if (s.imdbId) q.set('imdbid', s.imdbId);
   if (s.tmdbId) q.set('tmdbid', s.tmdbId);
   if (s.tvdbId) q.set('tvdbid', s.tvdbId);
+  /*
+   * Un mot par groupe, et ce mot EST la liste des synonymes, séparés par des
+   * virgules — la forme que la barre relit sans repasser par sa table d'alias.
+   * Le premier synonyme seul (`tk=hevc`) se ré-étendait à toute la famille : une
+   * alerte enregistrée sur deux codecs sur quatre en rouvrait quatre.
+   */
+  if (s.tagGroups) {
+    const groups = s.tagGroups
+      .split(';')
+      .map((g) => Array.from(new Set(g.split(',').map((x) => x.trim()).filter(Boolean))).join(','))
+      .filter(Boolean);
+    if (groups.length) q.set('tk', groups.join(' '));
+  }
+  if (typeof s.season === 'number') q.set('se', String(s.season));
+  if (typeof s.episode === 'number') q.set('ep', String(s.episode));
+  if (typeof s.year === 'number') q.set('y', String(s.year));
   const qs = q.toString();
   return qs ? `/torrents?${qs}` : '/torrents';
 }
diff --git a/apps/web/app/utils/searchTokens.ts b/apps/web/app/utils/searchTokens.ts
new file mode 100644
index 00000000..e2175b70
--- /dev/null
+++ b/apps/web/app/utils/searchTokens.ts
@@ -0,0 +1,352 @@
+import { detectMediaId, type DetectedMediaId } from '~/utils/mediaIdDetect';
+
+/**
+ * Ce que la barre du catalogue comprend en tapant.
+ *
+ * Une recherche de tracker ressemble à « frieren 1080p x265 vostfr s02 » :
+ * un titre et des qualificatifs. Ici, chaque mot que l'on sait nommer devient
+ * un jeton typé — résolution, source, codec, langue, audio, HDR, saison,
+ * épisode, année, uploadeur, identifiant externe — et le reste redevient le
+ * texte cherché. Les jetons d'une même famille se cumulent en OU (« 1080p
+ * 2160p » = l'une ou l'autre), les familles se croisent en ET.
+ *
+ * Les alias sont volontairement larges (`x265` et `hevc` désignent le même
+ * codec, `vostfr` et `vost` la même langue) : un jeton porte TOUS les slugs
+ * qu'il peut vouloir dire, et l'API teste « au moins un existe » — un synonyme
+ * absent du vocabulaire de l'instance ne vide pas le résultat.
+ */
+export type TagKind = 'resolution' | 'source' | 'codec' | 'language' | 'audio' | 'hdr';
+export type TokenKind =
+  | TagKind
+  | 'season'
+  | 'episode'
+  | 'year'
+  | 'uploader'
+  | 'imdb'
+  | 'tmdb'
+  | 'tvdb';
+
+export interface SearchToken {
+  kind: TokenKind;
+  /** Ce que l'utilisateur a tapé, tel quel, pour la puce. */
+  raw: string;
+  /** La valeur canonique : slugs d'étiquette, numéro, nom, identifiant. */
+  value: string;
+  /** Pour les familles d'étiquettes : les slugs équivalents (OU). */
+  slugs?: string[];
+}
+
+/** Les familles portées par les étiquettes, et leurs alias → slugs. */
+const TAG_KINDS: readonly TagKind[] = ['resolution', 'source', 'codec', 'language', 'audio', 'hdr'];
+
+const ALIASES: Record<TagKind, Record<string, string[]>> = {
+  resolution: {
+    '480p': ['480p'],
+    '576p': ['576p'],
+    '720p': ['720p'],
+    '1080p': ['1080p'],
+    '1080i': ['1080i', '1080p'],
+    '2160p': ['2160p', '4k', 'uhd'],
+    '4k': ['2160p', '4k', 'uhd'],
+    uhd: ['2160p', '4k', 'uhd'],
+    '4320p': ['4320p', '8k'],
+    '8k': ['4320p', '8k'],
+  },
+  source: {
+    bluray: ['bluray', 'blu-ray', 'bdrip', 'brrip'],
+    'blu-ray': ['bluray', 'blu-ray', 'bdrip', 'brrip'],
+    bdrip: ['bdrip', 'bluray'],
+    brrip: ['brrip', 'bluray'],
+    remux: ['remux'],
+    web: ['web', 'web-dl', 'webrip'],
+    'web-dl': ['web-dl', 'web'],
+    webdl: ['web-dl', 'web'],
+    webrip: ['webrip', 'web'],
+    hdtv: ['hdtv'],
+    dvdrip: ['dvdrip', 'dvd'],
+    dvd: ['dvd', 'dvdrip'],
+    cam: ['cam'],
+    ts: ['ts', 'telesync'],
+  },
+  codec: {
+    x264: ['x264', 'avc', 'h264', 'h-264'],
+    h264: ['h264', 'h-264', 'avc', 'x264'],
+    'h.264': ['h264', 'h-264', 'avc', 'x264'],
+    avc: ['avc', 'x264', 'h264'],
+    x265: ['x265', 'hevc', 'h265', 'h-265'],
+    h265: ['h265', 'h-265', 'hevc', 'x265'],
+    'h.265': ['h265', 'h-265', 'hevc', 'x265'],
+    hevc: ['hevc', 'x265', 'h265'],
+    av1: ['av1'],
+    xvid: ['xvid'],
+    vp9: ['vp9'],
+  },
+  language: {
+    vf: ['vf', 'vff', 'vfq', 'french', 'truefrench'],
+    vff: ['vff', 'vf', 'truefrench'],
+    vfq: ['vfq', 'vf'],
+    vfi: ['vfi', 'vf'],
+    truefrench: ['truefrench', 'vff', 'vf'],
+    french: ['french', 'vf', 'vff'],
+    vostfr: ['vostfr', 'vost'],
+    vost: ['vost', 'vostfr'],
+    vo: ['vo', 'english'],
+    english: ['english', 'vo'],
+    multi: ['multi', 'multi-vf', 'multi-vff'],
+    'multi-vf': ['multi-vf', 'multi'],
+    'multi-vff': ['multi-vff', 'multi'],
+    'multi-vfq': ['multi-vfq', 'multi'],
+    subfrench: ['subfrench', 'vostfr'],
+  },
+  audio: {
+    aac: ['aac'],
+    ac3: ['ac-3', 'ac3', 'dd', 'dolby-digital'],
+    'ac-3': ['ac-3', 'ac3', 'dd'],
+    dd: ['dd', 'ac-3'],
+    eac3: ['eac-3', 'eac3', 'ddp', 'dd-plus'],
+    'eac-3': ['eac-3', 'eac3', 'ddp'],
+    ddp: ['ddp', 'eac-3', 'dd-plus'],
+    'dd+': ['ddp', 'eac-3', 'dd-plus'],
+    dts: ['dts', 'dts-hd', 'dts-hd-ma', 'dts-x'],
+    'dts-hd': ['dts-hd', 'dts-hd-ma'],
+    'dts-x': ['dts-x'],
+    dtsx: ['dts-x'],
+    atmos: ['atmos'],
+    truehd: ['truehd', 'true-hd'],
+    'true-hd': ['truehd', 'true-hd'],
+    flac: ['flac'],
+    opus: ['opus'],
+    '2.0': ['2-0', 'stereo'],
+    stereo: ['stereo', '2-0'],
+    '5.1': ['5-1'],
+    '7.1': ['7-1'],
+  },
+  hdr: {
+    hdr: ['hdr', 'hdr10', 'hdr10plus', 'hdr10-plus', 'dolby-vision', 'dv'],
+    hdr10: ['hdr10', 'hdr'],
+    'hdr10+': ['hdr10plus', 'hdr10-plus', 'hdr'],
+    hdr10plus: ['hdr10plus', 'hdr10-plus', 'hdr'],
+    dv: ['dv', 'dolby-vision'],
+    dovi: ['dolby-vision', 'dv'],
+    'dolby-vision': ['dolby-vision', 'dv'],
+    dolbyvision: ['dolby-vision', 'dv'],
+    sdr: ['sdr'],
+  },
+};
+
+/** Chaque slug connu → sa famille ; la première famille qui le nomme gagne. */
+const KIND_OF_SLUG: Map<string, TagKind> = (() => {
+  const m = new Map<string, TagKind>();
+  for (const kind of TAG_KINDS) {
+    for (const slugs of Object.values(ALIASES[kind])) {
+      for (const slug of slugs) if (!m.has(slug)) m.set(slug, kind);
+    }
+  }
+  return m;
+})();
+
+/** La famille d'un slug d'étiquette, ou `null` s'il n'en a pas (proper, 10bit…). */
+export function kindOfSlug(slug: string): TagKind | null {
+  return KIND_OF_SLUG.get(slug.toLowerCase()) ?? null;
+}
+
+/** Ce slug est-il déjà dans un jeton ? */
+export function hasSlug(tokens: SearchToken[], slug: string): boolean {
+  return tokens.some((t) => t.slugs?.includes(slug));
+}
+
+/**
+ * Coche ou décoche un slug depuis le rail : un jeton par famille, ses slugs en
+ * OU. Un slug coché depuis le rail vaut pour lui seul — pas pour ses
+ * synonymes, c'est le compte affiché à côté qui fait foi.
+ */
+export function toggleSlug(tokens: SearchToken[], kind: TagKind, slug: string): SearchToken[] {
+  const out = tokens.map((t) => ({ ...t, slugs: t.slugs ? [...t.slugs] : undefined }));
+  const same = out.find((t) => t.kind === kind);
+  if (!same) return [...out, { kind, raw: slug, value: slug, slugs: [slug] }];
+  const current = same.slugs ?? [];
+  same.slugs = current.includes(slug) ? current.filter((s) => s !== slug) : [...current, slug];
+  // Virgules, pas espaces : l'URL porte alors UN mot qui est la liste exacte,
+  // et `tokenize` la relit sans repasser par la table des synonymes. Avec des
+  // espaces, décocher « hevc » ne survivait pas au rechargement — le mot
+  // « x265 » ré-étendait toute sa famille.
+  same.raw = same.slugs.join(',');
+  same.value = same.slugs[0] ?? '';
+  return same.slugs.length ? out : out.filter((t) => t !== same);
+}
+
+/** Ce qu'un mot devient, ou `null` s'il fait partie du texte cherché. */
+export function tokenize(word: string): SearchToken | null {
+  const raw = word.trim();
+  if (!raw) return null;
+  const lower = raw.toLowerCase();
+
+  if (lower.startsWith('@') && lower.length > 1 && /^@[\w.-]{1,64}$/.test(lower)) {
+    return { kind: 'uploader', raw, value: raw.slice(1) };
+  }
+
+  // s02e04 / s02 / e04 / saison 2 arrive séparé (« saison », « 2 ») : on ne
+  // reconnaît que la forme compacte, la seule non ambiguë sans contexte.
+  const se = lower.match(/^s(\d{1,3})(?:e(\d{1,4}))?$/);
+  if (se) {
+    // s02e04 : deux jetons — l'appelant les recompose via `tokenizeAll`.
+    return { kind: 'season', raw, value: String(Number(se[1])), slugs: se[2] ? [String(Number(se[2]))] : undefined };
+  }
+  const ep = lower.match(/^e(?:p)?(\d{1,4})$/);
+  if (ep) return { kind: 'episode', raw, value: String(Number(ep[1])) };
+
+  if (/^(19|20)\d{2}$/.test(lower)) return { kind: 'year', raw, value: lower };
+
+  // Une liste explicite (`x265,h265,h-265`) : ce que le rail a coché, tel quel.
+  // Aucune extension par synonymes, sinon décocher n'aurait aucun effet durable.
+  if (lower.includes(',')) {
+    const parts = Array.from(new Set(lower.split(',').map((p) => p.trim()).filter(Boolean)));
+    const kinds = new Set(parts.map((p) => KIND_OF_SLUG.get(p)));
+    const only = parts.length > 0 && kinds.size === 1 ? [...kinds][0] : undefined;
+    if (only) return { kind: only, raw: parts.join(','), value: parts[0]!, slugs: parts };
+  }
+
+  for (const kind of TAG_KINDS) {
+    const slugs = ALIASES[kind][lower];
+    if (slugs) return { kind, raw, value: slugs[0]!, slugs: Array.from(new Set(slugs)) };
+  }
+  // Un slug d'étiquette que le rail a coché (`2-0`, `dolby-vision`) : il n'est
+  // pas une clé d'alias mais il a une famille, il doit survivre à l'URL.
+  const slugKind = KIND_OF_SLUG.get(lower);
+  if (slugKind) return { kind: slugKind, raw, value: lower, slugs: [lower] };
+
+  const media: DetectedMediaId | null = detectMediaId(raw);
+  if (media && (media.source === 'imdb' || media.source === 'tmdb' || media.source === 'tvdb')) {
+    return { kind: media.source, raw, value: media.id };
+  }
+  return null;
+}
+
+/** Une saisie entière → ses jetons et le texte restant. */
+export function parseSearchInput(input: string): { tokens: SearchToken[]; text: string } {
+  const tokens: SearchToken[] = [];
+  const rest: string[] = [];
+  for (const word of input.split(/\s+/)) {
+    if (!word) continue;
+    const t = tokenize(word);
+    if (!t) {
+      rest.push(word);
+      continue;
+    }
+    if (t.kind === 'season' && t.slugs?.length) {
+      // s02e04 : la saison porte l'épisode dans `slugs` le temps du transport.
+      const episode = t.slugs[0]!;
+      tokens.push({ kind: 'season', raw: t.raw, value: t.value });
+      tokens.push({ kind: 'episode', raw: t.raw, value: episode });
+      continue;
+    }
+    tokens.push(t);
+  }
+  return { tokens: mergeTokens(tokens), text: rest.join(' ') };
+}
+
+/**
+ * Deux jetons de la même famille d'étiquettes ne font qu'un groupe (OU) ; un
+ * numéro ou un nom ne peut valoir qu'une fois — le dernier tapé gagne.
+ */
+export function mergeTokens(tokens: SearchToken[]): SearchToken[] {
+  const out: SearchToken[] = [];
+  for (const t of tokens) {
+    const isTagKind = (TAG_KINDS as readonly string[]).includes(t.kind);
+    if (isTagKind) {
+      const same = out.find((o) => o.kind === t.kind);
+      if (same) {
+        same.slugs = Array.from(new Set([...(same.slugs ?? []), ...(t.slugs ?? [])]));
+        // Deux mots d'une même famille : le libellé les joint, et la forme
+        // reste celle que `tokenize` sait relire (virgules si l'un est une liste).
+        same.raw = same.raw.includes(',') || t.raw.includes(',') ? same.slugs.join(',') : `${same.raw} ${t.raw}`;
+        continue;
+      }
+      out.push({ ...t, slugs: [...(t.slugs ?? [])] });
+      continue;
+    }
+    const idx = out.findIndex((o) => o.kind === t.kind);
+    if (idx >= 0) out.splice(idx, 1);
+    out.push({ ...t });
+  }
+  return out;
+}
+
+/**
+ * La place du groupe d'une famille dans `tagGroups` (même ordre que
+ * `tokensToQuery`), ou -1 si la famille n'a pas de jeton : c'est la clé de
+ * `tagsByGroup` dans la réponse des facettes.
+ */
+export function tagGroupIndex(tokens: SearchToken[], kind: TagKind): number {
+  const groups = tokens.filter((t) => (TAG_KINDS as readonly string[]).includes(t.kind) && t.slugs?.length);
+  return groups.findIndex((t) => t.kind === kind);
+}
+
+/** Les paramètres d'API que ces jetons produisent (voir `torrentQuerySchema`). */
+export function tokensToQuery(tokens: SearchToken[]): Record<string, string | undefined> {
+  const groups = tokens
+    .filter((t) => (TAG_KINDS as readonly string[]).includes(t.kind) && t.slugs?.length)
+    .map((t) => t.slugs!.join(','));
+  const one = (kind: TokenKind) => tokens.find((t) => t.kind === kind)?.value;
+  return {
+    tagGroups: groups.length ? groups.join(';') : undefined,
+    season: one('season'),
+    episode: one('episode'),
+    year: one('year'),
+    uploader: one('uploader'),
+  };
+}
+
+/**
+ * Les paramètres d'URL — courts, lisibles, et surtout REVERSIBLES : le
+ * groupe garde le mot tapé (`x265`, pas ses quatre slugs) pour que la puce
+ * se relise à l'identique après un rechargement.
+ */
+export function tokensToUrl(tokens: SearchToken[]): Record<string, string | undefined> {
+  const words = tokens
+    .filter((t) => (TAG_KINDS as readonly string[]).includes(t.kind))
+    .flatMap((t) => t.raw.split(' '));
+  const one = (kind: TokenKind) => tokens.find((t) => t.kind === kind)?.value;
+  return {
+    tk: words.length ? words.join(' ') : undefined,
+    se: one('season'),
+    ep: one('episode'),
+    y: one('year'),
+    u: one('uploader'),
+  };
+}
+
+const str = (v: unknown): string | undefined => (typeof v === 'string' && v.trim() ? v.trim() : undefined);
+
+/** L'inverse de `tokensToUrl` : ce que la page relit au chargement. */
+export function tokensFromQuery(query: Record<string, unknown>): SearchToken[] {
+  const tokens: SearchToken[] = [];
+  const tk = str(query.tk);
+  if (tk) tokens.push(...parseSearchInput(tk).tokens.filter((t) => (TAG_KINDS as readonly string[]).includes(t.kind)));
+  const se = str(query.se);
+  if (se && /^\d{1,3}$/.test(se)) tokens.push({ kind: 'season', raw: `s${se.padStart(2, '0')}`, value: String(Number(se)) });
+  const ep = str(query.ep);
+  if (ep && /^\d{1,4}$/.test(ep)) tokens.push({ kind: 'episode', raw: `e${ep.padStart(2, '0')}`, value: String(Number(ep)) });
+  const y = str(query.y);
+  if (y && /^(19|20)\d{2}$/.test(y)) tokens.push({ kind: 'year', raw: y, value: y });
+  const u = str(query.u);
+  if (u && /^[\w.-]{1,64}$/.test(u)) tokens.push({ kind: 'uploader', raw: `@${u}`, value: u });
+  return mergeTokens(tokens);
+}
+
+/** Les slugs qu'une recherche enregistrée peut retenir de ces jetons. */
+export function tokenSlugs(tokens: SearchToken[]): string[] {
+  return Array.from(new Set(tokens.flatMap((t) => (t.slugs?.length ? [t.slugs[0]!] : []))));
+}
+
+/** Le texte de la puce : « S02 », « E04 », « @nom », ou le mot tapé. */
+export function tokenLabel(t: SearchToken): string {
+  if (t.kind === 'season') return `S${t.value.padStart(2, '0')}`;
+  if (t.kind === 'episode') return `E${t.value.padStart(2, '0')}`;
+  if (t.kind === 'uploader') return `@${t.value}`;
+  if (t.kind === 'imdb' || t.kind === 'tmdb' || t.kind === 'tvdb') return t.value;
+  // Une liste explicite se lit avec des points médians, pas avec des virgules collées.
+  return t.raw.includes(',') ? t.raw.split(',').join(' · ') : t.raw;
+}
+
+export const TAG_TOKEN_KINDS = TAG_KINDS;
diff --git a/apps/web/app/utils/seedObligation.ts b/apps/web/app/utils/seedObligation.ts
new file mode 100644
index 00000000..3b279e76
--- /dev/null
+++ b/apps/web/app/utils/seedObligation.ts
@@ -0,0 +1,97 @@
+/**
+ * Ce que le membre doit encore à un torrent, réduit à ce qui s'affiche.
+ *
+ * La règle tient en cinq champs sur le fil — `downloaded`, `seedTime`,
+ * `requiredSeedTime`, `isHnr`, `isExempt` — et en aucune façon en un état :
+ * « exempté », « en défaut », « rempli » et « pas encore pris » sont quatre
+ * réponses différentes à la même question, et les déduire dans le gabarit
+ * revient à écrire quatre `v-if` imbriqués dont l'ordre porte la logique.
+ *
+ * Une fonction pure, donc, plutôt qu'un calcul recopié dans la carte et dans
+ * la barre basse — les deux annoncent le même chiffre au même instant, et un
+ * arrondi divergent entre les deux serait le genre d'écart que personne ne
+ * remarque avant de le lire dans un rapport de bug.
+ *
+ * L'ordre des tests EST la spécification :
+ *
+ *  1. `isExempt` d'abord. Un membre exempté ne doit rien, qu'il ait pris la
+ *     release ou non — le tester après `downloaded` aurait annoncé un
+ *     engagement de 72 h à quelqu'un qui n'en a aucun.
+ *  2. `!downloaded` ensuite : rien n'est dû, mais quelque chose SERA dû. La
+ *     page s'en sert pour répondre à « est-ce que je peux la tenir ? » avant
+ *     le clic, pas après.
+ *  3. `isHnr` avant le compte : le serveur a tranché, et un défaut constaté
+ *     ne se rattrape pas par un pourcentage qui vient de passer à 100.
+ */
+
+/**
+ * La forme structurelle qu'attend `obligationView`.
+ *
+ * Volontairement pas un import de `SeedObligation` : un `utils/` qui dépend
+ * d'un `composables/` inverse la seule dépendance qui doit rester à sens
+ * unique. Le typage structurel de TypeScript fait que l'objet du composable
+ * passe ici sans conversion.
+ */
+export interface SeedObligationLike {
+  /** Le membre a-t-il déjà pris cette release ? */
+  downloaded: boolean;
+  /** Secondes de partage accomplies. */
+  seedTime: number;
+  /** Secondes de partage exigées. */
+  requiredSeedTime: number;
+  isHnr: boolean;
+  isExempt: boolean;
+}
+
+export type ObligationState = 'exempt' | 'pending' | 'hnr' | 'met' | 'running';
+
+export interface ObligationView {
+  state: ObligationState;
+  /** 0 à 100, borné — la largeur de la jauge. */
+  percent: number;
+  /** Secondes restantes avant libération ; 0 dès que l'obligation est levée. */
+  remaining: number;
+  /** Secondes accomplies, assainies. */
+  seedTime: number;
+  /** Secondes exigées, assainies. */
+  requiredSeedTime: number;
+  /** L'obligation est-elle derrière le membre — d'une façon ou d'une autre ? */
+  settled: boolean;
+}
+
+export function obligationView(
+  o: SeedObligationLike | null | undefined,
+): ObligationView | null {
+  if (!o) return null;
+
+  const requiredSeedTime = Math.max(0, o.requiredSeedTime || 0);
+  const seedTime = Math.max(0, o.seedTime || 0);
+  const remaining = Math.max(0, requiredSeedTime - seedTime);
+
+  // Une exigence à zéro est REMPLIE, pas indéterminée. La division brute
+  // donnait `NaN`, qui traverse `Math.min` sans broncher et arrivait dans un
+  // `width:NaN%` — une jauge vide sur une obligation qui n'existait pas.
+  const percent =
+    requiredSeedTime <= 0
+      ? 100
+      : Math.min(100, Math.round((seedTime / requiredSeedTime) * 100));
+
+  const state: ObligationState = o.isExempt
+    ? 'exempt'
+    : !o.downloaded
+      ? 'pending'
+      : o.isHnr
+        ? 'hnr'
+        : remaining === 0
+          ? 'met'
+          : 'running';
+
+  return {
+    state,
+    percent,
+    remaining,
+    seedTime,
+    requiredSeedTime,
+    settled: state === 'exempt' || state === 'met',
+  };
+}
diff --git a/apps/web/app/utils/versionMarkers.ts b/apps/web/app/utils/versionMarkers.ts
new file mode 100644
index 00000000..c4097233
--- /dev/null
+++ b/apps/web/app/utils/versionMarkers.ts
@@ -0,0 +1,270 @@
+/**
+ * Ce qui distingue deux VERSIONS d'une même unité.
+ *
+ * # Le rang par taille racontait n'importe quoi
+ *
+ * La fiche classait les releases d'un groupe par taille et posait trois rangs
+ * d'usage dessus : la plus grosse « Image max », la plus petite « Léger ». Deux
+ * pannes, et la première est celle qui a déclenché ce fichier :
+ *
+ *   1. Entre UNITÉS, c'est un mensonge complet. La page de `Cats.Eye.S01`
+ *      affichait `Cats.Eye.S02` étiquetée « Image max » et `S01` « Léger » : la
+ *      saison 2 présentée comme une meilleure variante de la saison 1. Ce sont
+ *      deux contenus différents. Le rang ne veut rien dire hors d'une unité, et
+ *      c'est le composant qui borne l'unité — ce fichier suppose que la liste
+ *      qu'on lui donne EST une seule unité.
+ *   2. Même à l'intérieur d'une unité, la taille ne dit pas la qualité d'image.
+ *      Mesuré sur le catalogue : `Sousou.no.Frieren.S01.VOSTFR.1080p.WEB-DL` pèse
+ *      42,9 Gio et `Sousou.no.Frieren.S01.MULTi.1080p.BluRay.x265.FLAC` 22,4 Gio.
+ *      Le rang par taille couronnait le WEB-DL et traitait le BluRay de
+ *      « Léger ». Les deux sont en 1080p ; c'est la SOURCE qui les sépare.
+ *
+ * # Des repères qui sont des propriétés, pas un classement
+ *
+ * Chaque repère nomme un besoin et n'est posé que sur une ligne qui a
+ * réellement la propriété correspondante :
+ *
+ *   · `imageMax`      — la meilleure image : résolution, puis HDR, puis source.
+ *                       La taille n'entre PAS dans ce calcul, c'est tout l'objet
+ *                       de la panne 2. Non attribué en cas d'égalité : si deux
+ *                       versions sont identiques sur ces trois axes, rien ne les
+ *                       sépare sur l'image et le prétendre serait inventer.
+ *   · `audioOriginal` — une piste intacte : TrueHD, DTS-HD, FLAC, Atmos, ou un
+ *                       REMUX (qui recopie les pistes du disque sans les
+ *                       toucher, donc l'audio est d'origine par construction).
+ *   · `compat`        — lit partout : H.264 et pas de piste lossless, en 1080p
+ *                       au plus. C'est le repère du tracker de référence, et la
+ *                       réponse à « ça passe sur ma télé / mon téléphone ? ».
+ *   · `light`         — la plus compacte, et seulement quand l'écart avec la
+ *                       suivante est réel (voir `LIGHT_MARGIN`).
+ *
+ * Un repère par ligne, une ligne par repère. Deux repères sur une même ligne
+ * casseraient la fente de largeur fixe qui aligne les colonnes suivantes, et
+ * c'est cet alignement qui permet de descendre une colonne sans lire un seul
+ * nom de fichier.
+ *
+ * `imageMax` et `light` sont des EXTREMUMS : ils n'ont qu'un titulaire
+ * possible, donc si celui-là porte déjà un repère, le repère saute — le donner
+ * au deuxième serait faux (la deuxième plus petite n'est pas « la plus
+ * compacte »). `audioOriginal` et `compat` sont des PROPRIÉTÉS : n'importe
+ * quelle ligne qui les porte peut légitimement l'annoncer, donc on descend
+ * jusqu'à la meilleure ligne encore libre : le REMUX 2160p prend `Image max`,
+ * et `Son d'origine` descend au BluRay 1080p DTS-HD, qui l'a réellement,
+ * plutôt que de disparaître avec la ligne déjà occupée.
+ *
+ * Enfin, un repère qui ne distingue rien ne s'affiche pas : si TOUTES les
+ * versions de l'unité sont en H.264/AAC, « Compat » n'aide personne à choisir.
+ * C'est ce qui arrive aux trois éditions de Dune du catalogue
+ * (`tmdb:693134`) : les trois portent une piste intacte — TrueHD, DTS-HD,
+ * DTS-HD — donc `Son d'origine` se TAIT, et seul `Image max` reste. Ne pas
+ * chercher le repère audio sur cette œuvre : son absence est le comportement,
+ * pas un manque.
+ */
+import { parseReleaseName } from '@trackarr/shared/releaseParse';
+
+export type VersionMarker = 'imageMax' | 'audioOriginal' | 'compat' | 'light';
+
+export interface VersionFacts {
+  /** Taille en octets ; 0 quand elle est inconnue. */
+  size: number;
+  /** Les jetons du nom de release, tels que `parseReleaseName` les rend. */
+  tags: readonly string[];
+}
+
+/**
+ * Les jetons d'un nom de release, ou aucun.
+ *
+ * Le même analyseur que le formulaire d'upload et que `releaseChips`, donc ce
+ * qui est comparé ici est exactement ce que la ligne affiche. Un nom qui le
+ * fait tomber rend une ligne sans repère — honnête — plutôt qu'un tableau cassé.
+ */
+export function releaseTags(name: string): string[] {
+  try {
+    return parseReleaseName(name).tags;
+  } catch {
+    return [];
+  }
+}
+
+// Les échelles. Volontairement grossières : elles ne servent qu'à ORDONNER des
+// releases d'une même unité, pas à noter une release dans l'absolu.
+const RESOLUTION_RANK: Record<string, number> = {
+  '2160p': 5,
+  '1440p': 4,
+  '1080p': 3,
+  '720p': 2,
+  '480p': 1,
+};
+
+/** Au-delà de ce rang, « lit partout » cesse d'être vrai. */
+const COMPAT_MAX_RESOLUTION = RESOLUTION_RANK['1080p']!;
+
+const SOURCE_RANK: Record<string, number> = {
+  REMUX: 6,
+  BluRay: 5,
+  UHD: 5,
+  'WEB-DL': 4,
+  WEB: 3,
+  WEBRip: 3,
+  HDRip: 2,
+  HDTV: 2,
+  DVDRip: 1,
+  DVD: 1,
+};
+
+// `10bit` et `SDR` sont absents exprès : le premier est une profondeur de
+// codage, le second l'absence de HDR. Ni l'un ni l'autre n'est une plage
+// dynamique étendue.
+const HDR_RANK: Record<string, number> = {
+  'Dolby Vision': 2,
+  'HDR10+': 2,
+  HDR10: 1,
+  HDR: 1,
+};
+
+/**
+ * Les pistes qu'un encodage ne retouche pas. `DTS` simple en est absent : le
+ * cœur DTS est compressé avec perte, contrairement à `DTS-HD` (MA).
+ */
+const AUDIO_ORIGINAL_RANK: Record<string, number> = {
+  Atmos: 4,
+  TrueHD: 3,
+  'DTS-HD': 2,
+  FLAC: 1,
+};
+
+/**
+ * L'écart minimal qui rend « Léger » informatif.
+ *
+ * Mesuré : les deux éditions 1080p de Dune du catalogue pèsent 18,254 Gio et
+ * 18,253 Gio. Coller « Léger » sur la seconde n'aide personne à choisir et
+ * suggère un écart qui n'existe pas. Le seuil se compare à la DEUXIÈME plus
+ * petite, pas à la plus grosse : c'est le voisin immédiat qui dit si l'écart
+ * est réel.
+ */
+const LIGHT_MARGIN = 0.9;
+
+function maxRank(
+  tags: readonly string[],
+  table: Record<string, number>,
+): number {
+  let best = 0;
+  for (const tag of tags) {
+    const rank = table[tag];
+    if (rank !== undefined && rank > best) best = rank;
+  }
+  return best;
+}
+
+interface Ranked {
+  at: number;
+  size: number;
+  resolution: number;
+  hdr: number;
+  source: number;
+  /** Rang de la piste d'origine ; 0 quand il n'y en a pas. */
+  audio: number;
+  /** H.264 explicitement annoncé. */
+  avc: boolean;
+}
+
+function rank(facts: VersionFacts, at: number): Ranked {
+  const tags = facts.tags;
+  const remux = tags.includes('REMUX');
+  return {
+    at,
+    size: facts.size,
+    resolution: maxRank(tags, RESOLUTION_RANK),
+    hdr: maxRank(tags, HDR_RANK),
+    source: maxRank(tags, SOURCE_RANK),
+    // Un REMUX sans jeton audio reconnu garde quand même les pistes du disque.
+    audio: maxRank(tags, AUDIO_ORIGINAL_RANK) || (remux ? 1 : 0),
+    avc: tags.includes('AVC'),
+  };
+}
+
+/** Meilleure image en premier. Zéro quand rien ne les sépare sur l'image. */
+function byPicture(a: Ranked, b: Ranked): number {
+  return b.resolution - a.resolution || b.hdr - a.hdr || b.source - a.source;
+}
+
+/**
+ * Le repère de chaque version, dans l'ordre reçu.
+ *
+ * La liste doit être UNE unité — un épisode, une saison, une intégrale, une
+ * œuvre sans découpe. Deux unités mélangées donnent des repères qui comparent
+ * des contenus différents, ce qui est précisément la panne que ce fichier
+ * remplace.
+ */
+export function assignVersionMarkers(
+  items: readonly VersionFacts[],
+): (VersionMarker | null)[] {
+  const out: (VersionMarker | null)[] = items.map(() => null);
+  // Une seule version n'est pas un choix : il n'y a rien à arbitrer, et un
+  // repère posé sur une ligne unique se lirait comme un jugement sur la
+  // release elle-même.
+  if (items.length < 2) return out;
+
+  const ranked = items.map(rank);
+
+  // 1 · L'image. Extremum : sauté en cas d'égalité, jamais reporté.
+  const picture = [...ranked].sort(byPicture);
+  if (byPicture(picture[0]!, picture[1]!) !== 0) {
+    out[picture[0]!.at] = 'imageMax';
+  }
+
+  // 2 · La piste d'origine. Propriété : reportée à la meilleure ligne libre.
+  const original = ranked.filter((r) => r.audio > 0);
+  if (original.length > 0 && original.length < ranked.length) {
+    const winner = original
+      .sort((a, b) => b.audio - a.audio || b.size - a.size)
+      .find((r) => out[r.at] === null);
+    if (winner) out[winner.at] = 'audioOriginal';
+  }
+
+  // 3 · La compatibilité. Propriété, même règle.
+  const compatible = ranked.filter(
+    (r) => r.avc && r.audio === 0 && r.resolution <= COMPAT_MAX_RESOLUTION,
+  );
+  if (compatible.length > 0 && compatible.length < ranked.length) {
+    const winner = compatible
+      .sort((a, b) => b.resolution - a.resolution || b.size - a.size)
+      .find((r) => out[r.at] === null);
+    if (winner) out[winner.at] = 'compat';
+  }
+
+  // 4 · La plus compacte. Extremum, comme l'image.
+  const bySize = [...ranked].sort((a, b) => a.size - b.size);
+  const smallest = bySize[0]!;
+  const second = bySize[1]!;
+  if (
+    smallest.size > 0 &&
+    smallest.size <= second.size * LIGHT_MARGIN &&
+    out[smallest.at] === null
+  ) {
+    out[smallest.at] = 'light';
+  }
+
+  return out;
+}
+
+/**
+ * Le groupe de release, ou `null`.
+ *
+ * `parseReleaseName` le RETIRE (`stripGroup`) sans jamais le rendre, donc ni
+ * `releaseChips` ni les jetons ne le portent — et c'est pourtant la colonne
+ * qui départage deux versions que tout le reste égalise. Mesuré sur l'unité
+ * `Sousou.no.Frieren.S01E09` : deux des quatre versions sont
+ * `VOSTFR/1080p/WEB-DL`, seules `TsundereRaws` et `NOTAG` les distinguent.
+ *
+ * Le motif est celui de `stripGroup`, à un garde-fou près. Le suffixe nu
+ * `-([A-Za-z0-9_]+)$` attrape aussi la queue d'un titre (`Movie.Part-2`), donc
+ * on exige au moins une lettre et deux caractères. Un nom sans suffixe rend
+ * `null` plutôt qu'une chaîne vide : la colonne affiche alors son tiret, ce
+ * qui est honnête.
+ */
+export function releaseGroup(name: string): string | null {
+  const m = /-([A-Za-z0-9_]{2,24})$/.exec(name.trim());
+  const tag = m?.[1];
+  return tag && /[A-Za-z]{2}/.test(tag) ? tag : null;
+}
diff --git a/apps/web/app/utils/workUnits.ts b/apps/web/app/utils/workUnits.ts
new file mode 100644
index 00000000..ae8b7053
--- /dev/null
+++ b/apps/web/app/utils/workUnits.ts
@@ -0,0 +1,67 @@
+import type { GroupScope, ScopeSummary } from '~/utils/groupScopes';
+
+/**
+ * La structure d'une œuvre dépliée : ses découpes et ses unités.
+ *
+ * Hors composant pour être testée : l'ordre des découpes, la découpe mise en
+ * avant, la répartition des releases en unités (épisode, saison, intégrale)
+ * selon la découpe ouverte — sans un mot de libellé, que le composant traduit.
+ */
+export const SCOPE_ORDER: readonly GroupScope[] = ['episode', 'season', 'integral', 'all'];
+
+export function scopesOf(scopes: ScopeSummary[] | undefined): ScopeSummary[] {
+  return (scopes ?? [])
+    .filter((s) => s.units > 0)
+    .sort((a, b) => SCOPE_ORDER.indexOf(a.scope) - SCOPE_ORDER.indexOf(b.scope));
+}
+
+/** La découpe mise en avant : celle du premier torrent du tri, sinon la plus récente, sinon la première qui existe. */
+export function homeScope(g: { scopes?: ScopeSummary[]; firstScope?: GroupScope; defaultScope?: GroupScope }): GroupScope {
+  const scopes = scopesOf(g.scopes);
+  const wanted = g.firstScope ?? g.defaultScope ?? 'all';
+  return scopes.some((s) => s.scope === wanted) ? wanted : scopes[0]?.scope ?? 'all';
+}
+
+export interface UnitRowLike {
+  season?: number | null;
+  episode?: number | null;
+}
+export type UnitKind = 'episode' | 'season' | 'integral' | 'all';
+export interface Unit<T> {
+  key: string;
+  kind: UnitKind;
+  season: number | null;
+  episode: number | null;
+  order: number;
+  rows: T[];
+}
+
+/**
+ * Les unités d'une découpe : les épisodes du plus récent au plus ancien, puis
+ * les saisons, puis l'intégrale. La découpe « all » range chaque release
+ * selon ce qu'elle est ; « integral » n'a qu'une unité.
+ */
+export function unitsOf<T extends UnitRowLike>(rows: T[], scope: GroupScope): Unit<T>[] {
+  const map = new Map<string, Unit<T>>();
+  for (const r of rows) {
+    const hasSeason = typeof r.season === 'number';
+    const hasEpisode = typeof r.episode === 'number';
+    let unit: Omit<Unit<T>, 'rows'>;
+    if (scope === 'episode' || (scope === 'all' && hasSeason && hasEpisode)) {
+      const s = r.season ?? 0;
+      const e = r.episode ?? 0;
+      unit = { key: `e${s}-${e}`, kind: 'episode', season: s, episode: e, order: 3_000_000 - (s * 10_000 + e) };
+    } else if (scope === 'season' || (scope === 'all' && hasSeason)) {
+      const s = r.season ?? 0;
+      unit = { key: `s${s}`, kind: 'season', season: s, episode: null, order: 5_000_000 - s };
+    } else if (scope === 'integral') {
+      unit = { key: 'integral', kind: 'integral', season: null, episode: null, order: 9_000_000 };
+    } else {
+      unit = { key: 'all', kind: 'all', season: null, episode: null, order: 9_000_000 };
+    }
+    const existing = map.get(unit.key);
+    if (existing) existing.rows.push(r);
+    else map.set(unit.key, { ...unit, rows: [r] });
+  }
+  return Array.from(map.values()).sort((a, b) => a.order - b.order);
+}
diff --git a/apps/web/i18n/locales/en.json b/apps/web/i18n/locales/en.json
index 49ad94d8..0f97cc70 100644
--- a/apps/web/i18n/locales/en.json
+++ b/apps/web/i18n/locales/en.json
@@ -109,7 +109,24 @@
     "closeNav": "Close navigation",
     "searchPlaceholder": "Search a torrent…",
     "searchAria": "Search torrents",
-    "searchHint": "Press / to focus"
+    "searchHint": "Press / to focus",
+    "torrentsMenu": {
+      "title": "Catalogue menu",
+      "toggle": "Open the catalogue menu",
+      "quick": "Shortcuts",
+      "all": "Whole catalogue",
+      "allHint": "works and releases",
+      "today": "Today",
+      "todayHint": "added in the last 24 h",
+      "free": "Freeleech",
+      "freeHint": "no weight on your ratio",
+      "favorites": "My favourites",
+      "favoritesHint": "the releases you follow",
+      "recent": "Recent searches",
+      "loading": "Loading categories…",
+      "empty": "No categories.",
+      "error": "Categories could not be loaded."
+    }
   },
   "home": {
     "trackerOnline": "Tracker online & operational",
@@ -877,7 +894,9 @@
         "nfo": "NFO",
         "crossSeeds": "Cross-seeds",
         "crossSeedsFederated": "Cross-seed on partners",
-        "swarm": "Peer list"
+        "swarm": "Peer list",
+        "noteExpand": "Show more",
+        "noteCollapse": "Collapse the note"
       },
       "crossSeedNote": "Grouped by matching file names and sizes only — a discovery hint, not a verified-content guarantee.",
       "crossSeedFederatedNote": "The same content on a partner instance. If you have an account there, cross-seed it from the files you already hold — fetched with your own partner passkey.",
@@ -935,7 +954,8 @@
         "deleted": "Torrent deleted",
         "favorited": "Added to your favorites.",
         "unfavorited": "Removed from your favorites.",
-        "favoriteFailed": "Could not update your favorites."
+        "favoriteFailed": "Could not update your favorites.",
+        "deleteFailed": "The release could not be deleted."
       },
       "errors": {
         "deleteFailed": "Failed to delete torrent"
@@ -952,7 +972,8 @@
         "copy": "You have adult content turned off in your settings. The page still exists, but everything on it — including the title and the full hash — is intentionally hidden until you toggle the setting back on.",
         "enable": "Enable adult content",
         "browseSafe": "Browse safe categories",
-        "footer": "Document withheld at viewer request"
+        "footer": "Document withheld at viewer request",
+        "metaTitle": "Filtered content"
       },
       "uploaderAnonymous": "Anonymous",
       "uploaderAnonymousTooltip": "This member chose not to have their name attached to their releases.",
@@ -985,7 +1006,8 @@
         "clear": "Lift it",
         "saved": "Marked as superseded.",
         "cleared": "Supersede marking lifted.",
-        "failed": "Could not update the supersede marking."
+        "failed": "Could not update the supersede marking.",
+        "hashPlaceholder": "40 hex"
       },
       "reseed": {
         "ask": "Ask for a reseed",
@@ -1000,6 +1022,237 @@
           "already": "Already asked today — one request a day."
         },
         "failed": "Could not send the request."
+      },
+      "expandAll": {
+        "label": "Show everything",
+        "shortcut": "for Ctrl+F",
+        "note": "Every section is open, so your browser's search (Ctrl+F / ⌘F) now covers the whole page. Uncheck to fold them back.",
+        "title": "Opens every section, so the browser's search (Ctrl+F) finds everything on the page."
+      },
+      "related": {
+        "seedersTitle": "{n} seeder | {n} seeders"
+      },
+      "versions": {
+        "title": "Versions",
+        "allReleases": "All releases",
+        "here": "Here",
+        "view": "View",
+        "viewAria": "View the version {name}",
+        "viewPartner": "Partner",
+        "viewPartnerAria": "View {name} on the partner instance",
+        "legend": {
+          "current": "the version shown on this page",
+          "more": "{n} more release →| {n} more releases →",
+          "unit": "No marker ever compares two episodes or two seasons: those are different contents, not variants.",
+          "diffMark": "Underlined",
+          "diff": "what differs from the release shown"
+        },
+        "col": {
+          "language": "Language",
+          "resolution": "Res.",
+          "source": "Source",
+          "codec": "Codec",
+          "group": "Group",
+          "name": "Filename",
+          "size": "Size",
+          "seeders": "Seeders"
+        },
+        "marker": {
+          "imageMax": "Max picture",
+          "imageMaxHint": "the best picture in this unit: resolution, then HDR, then source. Size plays no part in it.",
+          "audioOriginal": "Untouched audio",
+          "audioOriginalHint": "a track the encode left alone: TrueHD, DTS-HD, FLAC, Atmos, or a REMUX.",
+          "compat": "Compat",
+          "compatHint": "plays anywhere: H.264, no lossless track, 1080p at most.",
+          "light": "Light",
+          "lightHint": "the most compact, and only when the gap to the next one is real."
+        },
+        "unit": {
+          "episodeLabel": "Episode",
+          "seasonLabel": "Season",
+          "cutLabel": "Cut",
+          "episodeValue": "Episode {n}",
+          "integral": "Complete run",
+          "whole": "The whole work",
+          "change": "Change",
+          "scopeRow": "Scope",
+          "seasonRow": "Season",
+          "episodeRow": "Episode",
+          "hint": "The markers only compare versions of the unit named above. Changing unit reloads the table.",
+          "backHere": "Back to this page's unit"
+        }
+      },
+      "nfoPanel": {
+        "expand": "Show the NFO",
+        "collapse": "Hide the NFO"
+      },
+      "tracks": {
+        "audioTitle": "Audio tracks",
+        "subsTitle": "Subtitles",
+        "expandAudio": "Show the audio tracks",
+        "collapseAudio": "Hide the audio tracks",
+        "expandSubs": "Show the subtitles",
+        "collapseSubs": "Hide the subtitles",
+        "col": {
+          "language": "Language",
+          "format": "Format",
+          "channels": "Channels",
+          "bitrate": "Bitrate",
+          "title": "Track name",
+          "kind": "Kind"
+        },
+        "flag": {
+          "default": "Default"
+        },
+        "kind": {
+          "full": "Full",
+          "forced": "Forced",
+          "sdh": "SDH"
+        },
+        "sourceNfo": "Read from the MediaInfo block in the NFO. The catalogue has no per-track columns yet, so this is parsed from the uploader's text rather than verified against the files.",
+        "sourceDescription": "Read from the MediaInfo block in the uploader's description. The catalogue has no per-track columns yet, so this is parsed from their text rather than verified against the files.",
+        "title": "Tracks",
+        "videoTitle": "Video",
+        "more": "+{n} more | +{n} more",
+        "fps": "fps",
+        "count": "{n} track | {n} tracks",
+        "less": "Collapse"
+      },
+      "comments": {
+        "title": "Comments",
+        "composerLabel": "Add a comment",
+        "placeholder": "Sync, quality, subtitles — whatever the next person needs to know.",
+        "send": "Post",
+        "sending": "Posting…",
+        "remaining": "{n} character left | {n} characters left",
+        "empty": "No comments yet. If you took this release, say how it went.",
+        "signInToComment": "Sign in to comment on this release.",
+        "uploaderBadge": "Uploader",
+        "authorGone": "Former member",
+        "errors": {
+          "failed": "Your comment could not be posted. Try again in a moment.",
+          "tooFast": "Too many actions in a row. Wait a few seconds and post again.",
+          "signIn": "Your session has expired. Sign in again to post.",
+          "restricted": "The uploader only accepts comments from accounts older than a month. {n} day to go. | The uploader only accepts comments from accounts older than a month. {n} days to go."
+        },
+        "loadOlder": "Show older comments",
+        "loadOlderFailed": "Older comments could not be loaded."
+      },
+      "identity": {
+        "releaseName": "Release name",
+        "copyName": "Copy the release name",
+        "originalTitle": "Original title: {title}",
+        "rating": "Rated {value} out of 10",
+        "votes": "{n} vote | {n} votes",
+        "director": "Dir. {names}",
+        "noPoster": "No poster",
+        "posterUnavailable": "No poster available for this work",
+        "posterAlt": "Poster for {title}",
+        "posterLoading": "Looking up the poster…",
+        "copyHash": "Copy the info hash",
+        "mediaLinks": "Media database entries",
+        "openOn": "Open on {provider} · {id}",
+        "idNoLink": "{provider} · {id} — no public link from this id",
+        "crumbLabel": "Breadcrumb",
+        "wrongMatch": "Wrong match?",
+        "wrongMatchTitle": "Report that this record does not match the release"
+      },
+      "quality": {
+        "label": "Release quality"
+      },
+      "chipKeys": {
+        "language": "lang",
+        "resolution": "res",
+        "source": "src",
+        "format": "fmt",
+        "codec": "codec",
+        "audio": "audio",
+        "hdr": "hdr",
+        "platform": "plat",
+        "flag": "flag"
+      },
+      "cta": {
+        "download": "Download the .torrent",
+        "seeders": "{n} seeder | {n} seeders",
+        "free": "free"
+      },
+      "decision": {
+        "files": "{n} file | {n} files",
+        "perLeecher": "{value} per leecher",
+        "inProgress": "downloading now",
+        "snatches": "all time",
+        "xseedShare": "{percent} cross-seed",
+        "xseedSwarm": "Cross-seed elsewhere: {seeders} seeders, {leechers} leechers",
+        "xseedBytes": "Of which cross-seed {size} ({percent})"
+      },
+      "buff": {
+        "freeleech": "Freeleech",
+        "upload": "Upload ×{n}",
+        "mixed": "Buff",
+        "freeleechNote": "This download does not count against your ratio.",
+        "uploadNote": "What you upload on this release counts {n}×.",
+        "mixedNote": "Multipliers apply to this release alone.",
+        "until": "Ends {left}"
+      },
+      "obligation": {
+        "title": "Your seed obligation",
+        "state": {
+          "exempt": "Exempt",
+          "pending": "Not downloaded yet",
+          "hnr": "In default (H&R)",
+          "met": "Obligation met",
+          "running": "In progress"
+        },
+        "remaining": "{time} left before you are free to stop seeding.",
+        "metNote": "You have seeded long enough. You are free to remove it.",
+        "exemptNote": "Nothing is owed on this release.",
+        "hnrNote": "You stopped short. Put it back online for {time} to clear the default.",
+        "pendingNote": "Taking this release commits you to {time} of seeding.",
+        "progress": "{done} seeded of the {required} required",
+        "requiredShort": "{time} required",
+        "meterLabel": "Seed time completed against the minimum required"
+      },
+      "dock": {
+        "label": "Release actions",
+        "seed": "seed",
+        "leech": "leech",
+        "owed": "seed owed"
+      },
+      "operator": {
+        "area": "Operator tools"
+      },
+      "back": "Back to the index",
+      "metaFallback": "Release",
+      "provenance": {
+        "tags": "Tags",
+        "tagLink": "Browse torrents tagged {name}"
+      },
+      "aside": {
+        "actions": "Your actions",
+        "onThisPage": "On this page",
+        "shortcuts": "Shortcuts",
+        "shortcutDownload": "download",
+        "shortcutFavorite": "favourite"
+      },
+      "cost": {
+        "title": "What it costs you",
+        "unchanged": "ratio unchanged",
+        "partial": "It counts ×{n} toward your ratio.",
+        "full": "It counts in full toward your ratio.",
+        "without": "Without the bonus: {before} → {after}.",
+        "noRatio": "No ratio yet: nothing downloaded so far.",
+        "fullUnchanged": "Counted in full, but too small to move your ratio at two decimals."
+      },
+      "health": {
+        "healthy": "Healthy swarm",
+        "fragile": "Fragile swarm",
+        "dead": "No source",
+        "sources": "{n} source | {n} sources",
+        "lastAnnounce": "last announce {when}",
+        "sparkAria": "Sources over {n} days: {values}",
+        "historySoon": "The seven-day curve appears from tomorrow.",
+        "nobody": "Nobody is seeding it right now.",
+        "lastAnnounceAlone": "Last announce {when}."
       }
     }
   },
@@ -1008,23 +1261,18 @@
     "titleAccent": "Torrents",
     "pageTitle": "Search Torrents",
     "resultView": "Result view",
-    "viewSimple": "Simple",
-    "viewGrouped": "Grouped",
+    "viewSimple": "Releases",
+    "viewGrouped": "Works",
     "searchPlaceholder": "Search by name, hash, or paste an IMDb / TMDb / TVDB link…",
     "clearMediaIdFilter": "Clear {label} filter",
     "tags": "Tags",
     "clear": "Clear",
-    "noTags": "No tags yet — they'll appear here once a torrent is tagged.",
     "torrentCount": "torrent | torrents",
     "searchingDatabase": "Searching database…",
     "noResults": "No results found",
-    "noResultsHint": "We couldn't find any torrents matching your search criteria. Try different keywords or filters.",
     "uncategorised": "Uncategorised",
-    "loadingTitle": "Loading title…",
-    "releaseCount": "release | releases",
     "page": "Page",
     "total": "total",
-    "trending": "Trending",
     "pager": {
       "pagination": "Pagination",
       "previousPage": "Previous page",
@@ -1064,16 +1312,174 @@
       "collapseAria": "Hide the releases of {title}"
     },
     "pinned": {
-      "title": "Pinned"
-    },
-    "saveSearch": {
-      "action": "Save this search",
-      "manage": "Manage alerts",
-      "saved": "Saved. You will be notified when a matching release is accepted.",
-      "failed": "Could not save this search.",
-      "limit": "You can keep {max} saved searches. Delete one on the Saved searches page first.",
-      "noCriteria": "Add some text, a category or a tag first — a saved search needs something to watch for.",
-      "untitled": "Untitled search"
+      "title": "Pinned",
+      "free": "free"
+    },
+    "tokens": {
+      "active": "Bar filters",
+      "inputLabel": "Search the catalogue",
+      "remove": "Remove the {label} {value} filter",
+      "resolution": "Res",
+      "source": "Source",
+      "codec": "Codec",
+      "language": "Lang",
+      "audio": "Audio",
+      "hdr": "HDR",
+      "season": "Season",
+      "episode": "Episode",
+      "year": "Year",
+      "uploader": "By",
+      "imdb": "IMDb",
+      "tmdb": "TMDb",
+      "tvdb": "TVDB"
+    },
+    "filters": {
+      "title": "Active filters",
+      "clearAll": "Clear all",
+      "category": "Cat",
+      "tag": "Tag",
+      "none": "No filter · type to search"
+    },
+    "sort": {
+      "label": "Sort",
+      "age": "Newest",
+      "name": "Name",
+      "size": "Size",
+      "seeders": "Seeders",
+      "leechers": "Leechers",
+      "completed": "Completed",
+      "asc": "Ascending",
+      "desc": "Descending",
+      "toggle": "Reverse the order",
+      "relevance": "Relevance"
+    },
+    "density": {
+      "label": "Density",
+      "comfortable": "Comfortable",
+      "compact": "Compact"
+    },
+    "rows": {
+      "release": "Release",
+      "quality": "Quality",
+      "size": "Size",
+      "by": "By",
+      "age": "Age",
+      "download": "Download the .torrent for {name}",
+      "free": "Free",
+      "replaced": "Replaced",
+      "taken": "Taken",
+      "shortcuts": "↑ ↓ browse · Enter open · D download · F favourite",
+      "swarm": {
+        "label": "Swarm",
+        "dead": "No seeder — {l} waiting",
+        "thin": "Fragile swarm: {s} seeder(s), {l} waiting",
+        "ok": "Healthy swarm: {s} seeders, {l} waiting",
+        "hot": "Very active swarm: {s} seeders, {l} waiting"
+      },
+      "freeHint": "Free: the download does not count towards your ratio",
+      "replacedHint": "Replaced: a corrected version exists",
+      "takenHint": "Taken: you already downloaded it",
+      "versions": "{n} other version | {n} other versions",
+      "versionsHide": "Collapse versions"
+    },
+    "results": "Results",
+    "facets": {
+      "title": "Filters",
+      "category": "Category",
+      "resolution": "Resolution",
+      "source": "Source",
+      "codec": "Codec",
+      "language": "Language",
+      "audio": "Audio",
+      "hdr": "HDR",
+      "year": "Year",
+      "options": "Options",
+      "more": "Show {n} more",
+      "less": "Show less",
+      "none": "Nothing to filter in this search",
+      "yearTitle": "{year} · {n} release | {year} · {n} releases",
+      "fresh": "Swarms collected {ago}"
+    },
+    "options": {
+      "chip": "Option",
+      "seeded": "With seeders",
+      "free": "Free",
+      "untaken": "Not taken yet",
+      "current": "Hide replaced",
+      "favorites": "My favourites",
+      "today": "Last 24 hours"
+    },
+    "works": {
+      "open": "Show releases",
+      "close": "Collapse",
+      "openPage": "Open the work’s page",
+      "releases": "{n} release | {n} releases",
+      "partners": "{n} also on partners",
+      "loading": "Loading releases…",
+      "error": "The releases could not be loaded. Try again.",
+      "empty": "No release of this work matches the filters.",
+      "unit": {
+        "episode": "S{s} · E{e}",
+        "season": "Season {s}",
+        "integral": "Complete",
+        "episodeShort": "E{e}"
+      },
+      "scopeRow": "Cut",
+      "episodes": "{n} episode | {n} episodes"
+    },
+    "alerts": {
+      "title": "My alerts",
+      "new": "{n} new",
+      "add": "Save the current search",
+      "manage": "Manage",
+      "muted": "Alert paused: it no longer notifies",
+      "manageMore": "Manage · {n} more"
+    },
+    "empty": {
+      "title": "Nothing for “{q}”",
+      "titleNoQuery": "Nothing with these filters",
+      "hint": "Here is what the catalogue gives if one criterion is dropped. Otherwise, request the release or leave an alert: the first one to arrive will notify you.",
+      "without": "Without {what}",
+      "text": "the text “{q}”",
+      "all": "In the whole catalogue",
+      "request": "Create a request",
+      "alert": "Alert me when it lands",
+      "didYouMean": "Did you mean:"
+    },
+    "sheet": {
+      "open": "Filters",
+      "title": "Filters",
+      "close": "Close the filters",
+      "apply": "See {n} result | See {n} results"
+    },
+    "suggest": {
+      "understood": "Recognised works",
+      "work": "work · {n} release | work · {n} releases",
+      "recent": "Recent",
+      "howTitle": "What the bar understands",
+      "loading": "Looking up works…",
+      "none": "No known work for “{q}” — Enter searches the releases",
+      "hints": {
+        "unit": "“s02e04”: a season, an episode",
+        "link": "Paste an IMDb, TMDb or TVDB link",
+        "uploader": "“{'@'}name”: one member’s uploads"
+      },
+      "viewed": "Recently viewed"
+    },
+    "count": {
+      "releases": "{n} release | {n} releases",
+      "works": "{n} work | {n} works",
+      "live": "{n} live swarm | {n} live swarms"
+    },
+    "loadMore": "Load {n} more",
+    "defaults": {
+      "save": "Make these filters my default",
+      "saved": "Saved: the catalogue will open like this",
+      "active": "Your defaults",
+      "clear": "Remove my defaults",
+      "cleared": "Defaults removed",
+      "failed": "The defaults could not be saved",
+      "hint": "The catalogue will open with these filters on all your devices"
     }
   },
   "users": {
@@ -1592,7 +1998,9 @@
         "inappropriate": "Inappropriate content",
         "harassment": "Harassment or abuse",
         "other": "Other — see details below",
-        "otherShort": "Other"
+        "otherShort": "Other",
+        "wrongMetadata": "Wrong work record — the film or series does not match the release",
+        "wrongMetadataShort": "Wrong record"
       },
       "toasts": {
         "submitted": "Report submitted successfully"
@@ -1859,7 +2267,8 @@
       "noMatch": "No section matches.",
       "closeMenu": "Close the admin menu",
       "audit": "Audit log",
-      "inviteTree": "Invite tree"
+      "inviteTree": "Invite tree",
+      "searchMisses": "Missed searches"
     },
     "descriptions": {
       "dashboard": "Tracker configuration and node management",
@@ -1884,7 +2293,8 @@
       "federationTaxonomy": "Map partners' category slugs onto your own categories",
       "listingTemplates": "Curate the listing layouts every member can pick in the upload wizard.",
       "audit": "Every change made from the staff console — who, what, when.",
-      "inviteTree": "Who vouched for a member, and who they let in."
+      "inviteTree": "Who vouched for a member, and who they let in.",
+      "searchMisses": "What members search for and do not find"
     },
     "taxonomy": {
       "confirmRemove": {
@@ -2506,6 +2916,16 @@
         "saveFailed": "Failed to save category",
         "deleteFailed": "Failed to delete category",
         "seedFailed": "Failed to seed categories"
+      },
+      "merge": {
+        "action": "Merge",
+        "hint": "Fold this category into another one",
+        "title": "Merge two categories",
+        "into": "Merge “{from}” into:",
+        "confirm": "Everything filed under “{from}” will move to “{into}”, then “{from}” will be deleted. This cannot be undone.",
+        "cancel": "Cancel",
+        "done": "{n} torrent(s) moved to “{into}”",
+        "failed": "The merge failed"
       }
     },
     "bonusRules": {
@@ -3956,7 +4376,41 @@
       },
       "fuzzy": "Typo tolerance",
       "fuzzyLabel": "Catch typos",
-      "fuzzyHint": "When a search finds nothing, a second pass looks for near matches — “crimsen” finds “Crimson”. It only runs against an otherwise empty page, but costs roughly ten times a normal search. Turn it off if the catalogue grows large or the server is under strain."
+      "fuzzyHint": "When a search finds nothing, a second pass looks for near matches — “crimsen” finds “Crimson”. It only runs against an otherwise empty page, but costs roughly ten times a normal search. Turn it off if the catalogue grows large or the server is under strain.",
+      "catalogue": {
+        "view": "View on arrival",
+        "viewHint": "What members see when they open the catalogue without a filter.",
+        "sort": "Default sort",
+        "sortHint": "“Automatic”: relevance as soon as a text is typed, newest otherwise.",
+        "pageSize": "Results per page",
+        "pageSizeHint": "From 10 to 50; “Load more” adds as many each time.",
+        "facets": "Rail facets",
+        "facetsHint": "The filter families offered on the left of the catalogue.",
+        "views": {
+          "grouped": "Works",
+          "simple": "Releases"
+        },
+        "sorts": {
+          "auto": "Automatic",
+          "age": "Newest",
+          "name": "Name",
+          "size": "Size",
+          "seeders": "Seeders",
+          "leechers": "Leechers",
+          "completed": "Completed"
+        },
+        "facetNames": {
+          "category": "Category",
+          "resolution": "Resolution",
+          "source": "Source",
+          "codec": "Codec",
+          "language": "Language",
+          "hdr": "HDR",
+          "audio": "Audio",
+          "year": "Year",
+          "options": "Options"
+        }
+      }
     },
     "messaging": {
       "title": "Messaging",
@@ -4149,6 +4603,36 @@
       "secretsKept": "Leave a password field empty to keep the one already saved.",
       "faultLead": "The last attempt failed:",
       "testWhen": "Available once the bot is in the channel."
+    },
+    "hnrSettings": {
+      "title": "Hit & Run",
+      "description": "A downloaded release must be seeded for a minimum time. Past the grace period without reaching it, it is flagged as a Hit & Run on the member’s account. The threshold is frozen on each download at click time: changing it does not re-grade past downloads.",
+      "enabled": "Hit & Run tracking",
+      "enabledHint": "Disabled, no obligation is created and nothing is ever flagged.",
+      "on": "Enabled",
+      "off": "Disabled",
+      "requiredHours": "Seed threshold",
+      "requiredHint": "The seed time required per release, in hours. This is what the torrent page announces before the download: “commits you to N h of seeding”. Zero: no obligation.",
+      "graceHours": "Grace period",
+      "graceHint": "The time allowed after the download before a release under the threshold is flagged.",
+      "hoursLabel": "hours",
+      "save": "Save",
+      "saved": "Saved"
+    },
+    "searchMisses": {
+      "title": "Searches without results",
+      "description": "What members searched for without finding anything, most frequent first. A handled line is cleared; “Create a request” opens the form with the text.",
+      "query": "Search",
+      "count": "Times",
+      "first": "First time",
+      "last": "Last time",
+      "delete": "Clear this line",
+      "clearAll": "Clear all",
+      "clearAllConfirm": "The list starts over. The next searches without results will fill it again.",
+      "empty": "No search without results yet.",
+      "request": "Create a request",
+      "search": "Run the search",
+      "failed": "The operation failed"
     }
   },
   "mod": {
diff --git a/apps/web/i18n/locales/fr.json b/apps/web/i18n/locales/fr.json
index e6747f93..ef5d9706 100644
--- a/apps/web/i18n/locales/fr.json
+++ b/apps/web/i18n/locales/fr.json
@@ -109,7 +109,24 @@
     "closeNav": "Fermer la navigation",
     "searchPlaceholder": "Rechercher un torrent…",
     "searchAria": "Rechercher des torrents",
-    "searchHint": "Appuyer sur / pour cibler"
+    "searchHint": "Appuyer sur / pour cibler",
+    "torrentsMenu": {
+      "title": "Menu du catalogue",
+      "toggle": "Ouvrir le menu du catalogue",
+      "quick": "Raccourcis",
+      "all": "Tout le catalogue",
+      "allHint": "œuvres et releases",
+      "today": "Du jour",
+      "todayHint": "ajoutés depuis 24 h",
+      "free": "Gratuits",
+      "freeHint": "sans peser sur votre ratio",
+      "favorites": "Mes favoris",
+      "favoritesHint": "les releases que vous suivez",
+      "recent": "Recherches récentes",
+      "loading": "Chargement des catégories…",
+      "empty": "Aucune catégorie.",
+      "error": "Les catégories n'ont pas pu être chargées."
+    }
   },
   "home": {
     "trackerOnline": "Tracker en ligne et opérationnel",
@@ -877,7 +894,9 @@
         "nfo": "NFO",
         "crossSeeds": "Cross-seeds",
         "crossSeedsFederated": "Cross-seed chez les partenaires",
-        "swarm": "Liste des peers"
+        "swarm": "Liste des peers",
+        "noteExpand": "Afficher la suite",
+        "noteCollapse": "Replier la note"
       },
       "crossSeedNote": "Regroupés uniquement sur la correspondance des noms et tailles de fichiers — un indice de découverte, pas une garantie de contenu vérifié.",
       "crossSeedFederatedNote": "Le même contenu sur une instance partenaire. Si vous y avez un compte, cross-seedez-le depuis les fichiers que vous détenez déjà — récupéré avec votre propre passkey partenaire.",
@@ -935,7 +954,8 @@
         "deleted": "Torrent supprimé",
         "favorited": "Ajouté à vos favoris.",
         "unfavorited": "Retiré de vos favoris.",
-        "favoriteFailed": "Impossible de modifier vos favoris."
+        "favoriteFailed": "Impossible de modifier vos favoris.",
+        "deleteFailed": "La release n'a pas pu être supprimée."
       },
       "errors": {
         "deleteFailed": "Échec de la suppression du torrent"
@@ -952,7 +972,8 @@
         "copy": "Vous avez désactivé le contenu adulte dans vos paramètres. La page existe toujours, mais tout son contenu — y compris le titre et le hash complet — est volontairement masqué tant que vous n'avez pas réactivé le paramètre.",
         "enable": "Activer le contenu adulte",
         "browseSafe": "Parcourir les catégories sûres",
-        "footer": "Document retenu à la demande du visiteur"
+        "footer": "Document retenu à la demande du visiteur",
+        "metaTitle": "Contenu filtré"
       },
       "uploaderAnonymous": "Anonyme",
       "uploaderAnonymousTooltip": "Ce membre a choisi de ne pas associer son nom à ses publications.",
@@ -985,7 +1006,8 @@
         "clear": "Retirer",
         "saved": "Marquée comme remplacée.",
         "cleared": "Marquage retiré.",
-        "failed": "Le marquage n'a pas pu être mis à jour."
+        "failed": "Le marquage n'a pas pu être mis à jour.",
+        "hashPlaceholder": "40 hex"
       },
       "reseed": {
         "ask": "Demander une remise en partage",
@@ -1000,6 +1022,237 @@
           "already": "Déjà demandé aujourd’hui — une demande par jour."
         },
         "failed": "La demande n'a pas pu être envoyée."
+      },
+      "expandAll": {
+        "label": "Tout afficher",
+        "shortcut": "pour Ctrl+F",
+        "note": "Toutes les sections sont ouvertes : la recherche du navigateur (Ctrl+F / ⌘F) couvre désormais la page entière. Décochez pour les replier.",
+        "title": "Déplie toutes les sections : la recherche du navigateur (Ctrl+F) retrouve alors tout le contenu de la fiche."
+      },
+      "related": {
+        "seedersTitle": "{n} seeder | {n} seeders"
+      },
+      "versions": {
+        "title": "Versions",
+        "allReleases": "Toutes les releases",
+        "here": "Ici",
+        "view": "Voir",
+        "viewAria": "Voir la version {name}",
+        "viewPartner": "Partenaire",
+        "viewPartnerAria": "Voir {name} chez le partenaire",
+        "legend": {
+          "current": "la version affichée sur cette page",
+          "more": "{n} release de plus →| {n} releases de plus →",
+          "unit": "Aucun repère ne compare deux épisodes ni deux saisons entre eux : ce sont des contenus différents, pas des variantes.",
+          "diffMark": "Souligné",
+          "diff": "ce qui change par rapport à la version affichée"
+        },
+        "col": {
+          "language": "Langue",
+          "resolution": "Résol.",
+          "source": "Source",
+          "codec": "Codec",
+          "group": "Groupe",
+          "name": "Nom du fichier",
+          "size": "Taille",
+          "seeders": "Seeders"
+        },
+        "marker": {
+          "imageMax": "Image max",
+          "imageMaxHint": "la meilleure image de cette unité : résolution, puis HDR, puis source. La taille n'entre pas dans le calcul.",
+          "audioOriginal": "Son d'origine",
+          "audioOriginalHint": "une piste que l'encodage n'a pas retouchée : TrueHD, DTS-HD, FLAC, Atmos, ou un REMUX.",
+          "compat": "Compat",
+          "compatHint": "lit partout : H.264, aucune piste lossless, 1080p au plus.",
+          "light": "Léger",
+          "lightHint": "la plus compacte, et seulement quand l'écart avec la suivante est réel."
+        },
+        "unit": {
+          "episodeLabel": "Épisode",
+          "seasonLabel": "Saison",
+          "cutLabel": "Découpe",
+          "episodeValue": "Épisode {n}",
+          "integral": "Intégrale",
+          "whole": "Œuvre entière",
+          "change": "Changer",
+          "scopeRow": "Portée",
+          "seasonRow": "Saison",
+          "episodeRow": "Épisode",
+          "hint": "Les repères ne comparent que les versions de l'unité ouverte ci-dessus. Changer d'unité recharge le tableau.",
+          "backHere": "Revenir à celle de cette page"
+        }
+      },
+      "nfoPanel": {
+        "expand": "Afficher le NFO",
+        "collapse": "Masquer le NFO"
+      },
+      "tracks": {
+        "audioTitle": "Pistes audio",
+        "subsTitle": "Sous-titres",
+        "expandAudio": "Afficher les pistes audio",
+        "collapseAudio": "Masquer les pistes audio",
+        "expandSubs": "Afficher les sous-titres",
+        "collapseSubs": "Masquer les sous-titres",
+        "col": {
+          "language": "Langue",
+          "format": "Format",
+          "channels": "Canaux",
+          "bitrate": "Débit",
+          "title": "Nom de piste",
+          "kind": "Type"
+        },
+        "flag": {
+          "default": "Défaut"
+        },
+        "kind": {
+          "full": "Intégral",
+          "forced": "Forcé",
+          "sdh": "SME"
+        },
+        "sourceNfo": "Lu dans le bloc MediaInfo du NFO. Le catalogue n'a pas encore de colonnes par piste : ceci est analysé depuis le texte de l'uploadeur, non vérifié sur les fichiers.",
+        "sourceDescription": "Lu dans le bloc MediaInfo de la description. Le catalogue n'a pas encore de colonnes par piste : ceci est analysé depuis le texte de l'uploadeur, non vérifié sur les fichiers.",
+        "title": "Pistes",
+        "videoTitle": "Vidéo",
+        "more": "+{n} autre | +{n} autres",
+        "fps": "i/s",
+        "count": "{n} piste | {n} pistes",
+        "less": "Réduire"
+      },
+      "comments": {
+        "title": "Commentaires",
+        "composerLabel": "Ajouter un commentaire",
+        "placeholder": "Synchro, qualité, sous-titres — ce que la personne suivante a besoin de savoir.",
+        "send": "Publier",
+        "sending": "Publication…",
+        "remaining": "{n} caractère restant | {n} caractères restants",
+        "empty": "Aucun commentaire. Si vous avez pris cette release, dites ce qu'elle valait.",
+        "signInToComment": "Connectez-vous pour commenter cette release.",
+        "uploaderBadge": "Uploadeur",
+        "authorGone": "Ancien membre",
+        "errors": {
+          "failed": "Le commentaire n'a pas pu être publié. Réessayez dans un instant.",
+          "tooFast": "Trop d'actions d'affilée. Patientez quelques secondes et republiez.",
+          "signIn": "Votre session a expiré. Reconnectez-vous pour publier.",
+          "restricted": "L'uploadeur n'accepte les commentaires que des comptes de plus d'un mois. Encore {n} jour. | L'uploadeur n'accepte les commentaires que des comptes de plus d'un mois. Encore {n} jours."
+        },
+        "loadOlder": "Voir les commentaires plus anciens",
+        "loadOlderFailed": "Les commentaires plus anciens n’ont pas pu être chargés."
+      },
+      "identity": {
+        "releaseName": "Nom de la release",
+        "copyName": "Copier le nom de la release",
+        "originalTitle": "Titre original : {title}",
+        "rating": "Note de {value} sur 10",
+        "votes": "{n} vote | {n} votes",
+        "director": "Réal. {names}",
+        "noPoster": "Sans affiche",
+        "posterUnavailable": "Aucune affiche disponible pour cette œuvre",
+        "posterAlt": "Affiche de {title}",
+        "posterLoading": "Recherche de l’affiche…",
+        "copyHash": "Copier l'infohash",
+        "mediaLinks": "Fiches de l'œuvre",
+        "openOn": "Ouvrir sur {provider} · {id}",
+        "idNoLink": "{provider} · {id} — pas de lien public depuis cet identifiant",
+        "crumbLabel": "Fil d'orientation",
+        "wrongMatch": "Mauvaise fiche ?",
+        "wrongMatchTitle": "Signaler que cette fiche ne correspond pas à la release"
+      },
+      "quality": {
+        "label": "Qualité de la release"
+      },
+      "chipKeys": {
+        "language": "lang",
+        "resolution": "rés",
+        "source": "src",
+        "format": "fmt",
+        "codec": "codec",
+        "audio": "audio",
+        "hdr": "hdr",
+        "platform": "plat",
+        "flag": "tag"
+      },
+      "cta": {
+        "download": "Télécharger le .torrent",
+        "seeders": "{n} seeder | {n} seeders",
+        "free": "gratuit"
+      },
+      "decision": {
+        "files": "{n} fichier | {n} fichiers",
+        "perLeecher": "{value} par leecher",
+        "inProgress": "en cours",
+        "snatches": "au total",
+        "xseedShare": "{percent} en cross-seed",
+        "xseedSwarm": "Cross-seed ailleurs : {seeders} seeders, {leechers} leechers",
+        "xseedBytes": "Dont part cross-seed {size} ({percent})"
+      },
+      "buff": {
+        "freeleech": "Gratuit",
+        "upload": "Envoi ×{n}",
+        "mixed": "Bonus",
+        "freeleechNote": "Ce téléchargement ne compte pas dans votre ratio.",
+        "uploadNote": "Ce que vous envoyez sur cette release compte ×{n}.",
+        "mixedNote": "Les multiplicateurs ne concernent que cette release.",
+        "until": "Se termine {left}"
+      },
+      "obligation": {
+        "title": "Votre obligation de seed",
+        "state": {
+          "exempt": "Exempté",
+          "pending": "Pas encore téléchargée",
+          "hnr": "En défaut (H&R)",
+          "met": "Obligation remplie",
+          "running": "En cours"
+        },
+        "remaining": "Il reste {time} avant de vous libérer.",
+        "metNote": "Vous avez assez partagé. Vous pouvez la retirer.",
+        "exemptNote": "Aucune obligation sur cette release.",
+        "hnrNote": "Vous vous êtes arrêté trop tôt. Remettez-la en ligne {time} pour régulariser.",
+        "pendingNote": "Prendre cette release vous engage à {time} de partage.",
+        "progress": "{done} de partage sur les {required} requises",
+        "requiredShort": "{time} requises",
+        "meterLabel": "Temps de seed accompli sur le minimum requis"
+      },
+      "dock": {
+        "label": "Actions de la release",
+        "seed": "seed",
+        "leech": "leech",
+        "owed": "de seed dus"
+      },
+      "operator": {
+        "area": "Outils d'exploitation"
+      },
+      "back": "Retour à l'index",
+      "metaFallback": "Release",
+      "provenance": {
+        "tags": "Tags",
+        "tagLink": "Voir les torrents avec le tag {name}"
+      },
+      "aside": {
+        "actions": "Vos actions",
+        "onThisPage": "Sur cette page",
+        "shortcuts": "Raccourcis",
+        "shortcutDownload": "télécharger",
+        "shortcutFavorite": "favoris"
+      },
+      "cost": {
+        "title": "Ce que ça vous coûte",
+        "unchanged": "ratio inchangé",
+        "partial": "Il compte ×{n} dans votre ratio.",
+        "full": "Il compte en entier dans votre ratio.",
+        "without": "Sans le bonus : {before} → {after}.",
+        "noRatio": "Pas encore de ratio : rien de téléchargé jusqu'ici.",
+        "fullUnchanged": "Comptée en entier, mais trop petite pour déplacer votre ratio à deux décimales."
+      },
+      "health": {
+        "healthy": "Essaim sain",
+        "fragile": "Essaim fragile",
+        "dead": "Aucune source",
+        "sources": "{n} source | {n} sources",
+        "lastAnnounce": "dernière annonce {when}",
+        "sparkAria": "Sources sur {n} jours : {values}",
+        "historySoon": "La courbe des sept jours apparaît dès demain.",
+        "nobody": "Personne ne la partage en ce moment.",
+        "lastAnnounceAlone": "Dernière annonce {when}."
       }
     }
   },
@@ -1008,23 +1261,18 @@
     "titleAccent": "Torrents",
     "pageTitle": "Recherche de torrents",
     "resultView": "Vue des résultats",
-    "viewSimple": "Simple",
-    "viewGrouped": "Groupé",
+    "viewSimple": "Releases",
+    "viewGrouped": "Œuvres",
     "searchPlaceholder": "Rechercher par nom, hash, ou collez un lien IMDb / TMDb / TVDB…",
     "clearMediaIdFilter": "Effacer le filtre {label}",
     "tags": "Tags",
     "clear": "Effacer",
-    "noTags": "Aucun tag pour l'instant — ils apparaîtront ici une fois qu'un torrent sera taggé.",
     "torrentCount": "torrent | torrents",
     "searchingDatabase": "Recherche dans la base…",
     "noResults": "Aucun résultat",
-    "noResultsHint": "Aucun torrent ne correspond à vos critères de recherche. Essayez d'autres mots-clés ou filtres.",
     "uncategorised": "Non classé",
-    "loadingTitle": "Chargement du titre…",
-    "releaseCount": "version | versions",
     "page": "Page",
     "total": "au total",
-    "trending": "Tendances",
     "pager": {
       "pagination": "Pagination",
       "previousPage": "Page précédente",
@@ -1064,16 +1312,174 @@
       "collapseAria": "Masquer les versions de {title}"
     },
     "pinned": {
-      "title": "Épinglés"
-    },
-    "saveSearch": {
-      "action": "Enregistrer cette recherche",
-      "manage": "Gérer les alertes",
-      "saved": "Enregistrée. Vous serez prévenu·e quand une release correspondante sera acceptée.",
-      "failed": "Cette recherche n'a pas pu être enregistrée.",
-      "limit": "Vous pouvez conserver {max} recherches enregistrées. Supprimez-en une depuis la page Recherches enregistrées.",
-      "noCriteria": "Ajoutez d’abord du texte, une catégorie ou un tag — une recherche enregistrée a besoin de quelque chose à surveiller.",
-      "untitled": "Recherche sans titre"
+      "title": "Épinglés",
+      "free": "gratuit"
+    },
+    "tokens": {
+      "active": "Filtres de la barre",
+      "inputLabel": "Rechercher dans le catalogue",
+      "remove": "Retirer le filtre {label} {value}",
+      "resolution": "Rés",
+      "source": "Source",
+      "codec": "Codec",
+      "language": "Langue",
+      "audio": "Audio",
+      "hdr": "HDR",
+      "season": "Saison",
+      "episode": "Épisode",
+      "year": "Année",
+      "uploader": "Par",
+      "imdb": "IMDb",
+      "tmdb": "TMDb",
+      "tvdb": "TVDB"
+    },
+    "filters": {
+      "title": "Filtres actifs",
+      "clearAll": "Tout effacer",
+      "category": "Cat",
+      "tag": "Tag",
+      "none": "Aucun filtre · tapez pour chercher"
+    },
+    "sort": {
+      "label": "Trier",
+      "age": "Nouveautés",
+      "name": "Nom",
+      "size": "Taille",
+      "seeders": "Seeders",
+      "leechers": "Leechers",
+      "completed": "Complétés",
+      "asc": "Ordre croissant",
+      "desc": "Ordre décroissant",
+      "toggle": "Inverser l’ordre",
+      "relevance": "Pertinence"
+    },
+    "density": {
+      "label": "Densité",
+      "comfortable": "Confortable",
+      "compact": "Compact"
+    },
+    "rows": {
+      "release": "Release",
+      "quality": "Qualité",
+      "size": "Taille",
+      "by": "Par",
+      "age": "Âge",
+      "download": "Télécharger le .torrent de {name}",
+      "free": "Gratuit",
+      "replaced": "Remplacée",
+      "taken": "Prise",
+      "shortcuts": "↑ ↓ parcourir · Entrée ouvrir · D télécharger · F favori",
+      "swarm": {
+        "label": "Essaim",
+        "dead": "Aucun seeder — {l} en attente",
+        "thin": "Essaim fragile : {s} seeder(s), {l} en attente",
+        "ok": "Essaim sain : {s} seeders, {l} en attente",
+        "hot": "Essaim très actif : {s} seeders, {l} en attente"
+      },
+      "freeHint": "Gratuit : le téléchargement ne compte pas dans votre ratio",
+      "replacedHint": "Remplacée : une version corrigée existe",
+      "takenHint": "Prise : vous l’avez déjà téléchargée",
+      "versions": "{n} autre version | {n} autres versions",
+      "versionsHide": "Replier les versions"
+    },
+    "results": "Résultats",
+    "facets": {
+      "title": "Filtres",
+      "category": "Catégorie",
+      "resolution": "Résolution",
+      "source": "Source",
+      "codec": "Codec",
+      "language": "Langue",
+      "audio": "Audio",
+      "hdr": "HDR",
+      "year": "Année",
+      "options": "Options",
+      "more": "Voir {n} de plus",
+      "less": "Réduire",
+      "none": "Rien à filtrer dans cette recherche",
+      "yearTitle": "{year} · {n} release | {year} · {n} releases",
+      "fresh": "Essaims relevés {ago}"
+    },
+    "options": {
+      "chip": "Option",
+      "seeded": "Avec des seeders",
+      "free": "Gratuit",
+      "untaken": "Pas encore pris",
+      "current": "Masquer les remplacées",
+      "favorites": "Mes favoris",
+      "today": "Dernières 24 h"
+    },
+    "works": {
+      "open": "Voir les releases",
+      "close": "Replier",
+      "openPage": "Ouvrir la page de l’œuvre",
+      "releases": "{n} release | {n} releases",
+      "partners": "{n} aussi chez des partenaires",
+      "loading": "Chargement des releases…",
+      "error": "Les releases n’ont pas pu être chargées. Réessayez.",
+      "empty": "Aucune release de cette œuvre ne correspond aux filtres.",
+      "unit": {
+        "episode": "S{s} · E{e}",
+        "season": "Saison {s}",
+        "integral": "Intégrale",
+        "episodeShort": "E{e}"
+      },
+      "scopeRow": "Découpe",
+      "episodes": "{n} épisode | {n} épisodes"
+    },
+    "alerts": {
+      "title": "Mes alertes",
+      "new": "{n} nouv.",
+      "add": "Enregistrer la recherche courante",
+      "manage": "Gérer",
+      "muted": "Alerte en pause : elle ne prévient plus",
+      "manageMore": "Gérer · {n} de plus"
+    },
+    "empty": {
+      "title": "Rien pour « {q} »",
+      "titleNoQuery": "Rien avec ces filtres",
+      "hint": "Voici ce que donne le catalogue si l’on retire un critère. Sinon, demandez la release ou laissez une alerte : la première qui arrive vous préviendra.",
+      "without": "Sans {what}",
+      "text": "le texte « {q} »",
+      "all": "Dans tout le catalogue",
+      "request": "Créer une demande",
+      "alert": "M’alerter quand ça sort",
+      "didYouMean": "Vouliez-vous dire :"
+    },
+    "sheet": {
+      "open": "Filtres",
+      "title": "Filtres",
+      "close": "Fermer les filtres",
+      "apply": "Voir {n} résultat | Voir {n} résultats"
+    },
+    "suggest": {
+      "understood": "Œuvres reconnues",
+      "work": "œuvre · {n} release | œuvre · {n} releases",
+      "recent": "Récentes",
+      "howTitle": "Ce que la barre comprend",
+      "loading": "Recherche des œuvres…",
+      "none": "Aucune œuvre connue pour « {q} » — Entrée cherche dans les releases",
+      "hints": {
+        "unit": "« s02e04 » : une saison, un épisode",
+        "link": "Collez un lien IMDb, TMDb ou TVDB",
+        "uploader": "« {'@'}nom » : les envois d’un membre"
+      },
+      "viewed": "Vu récemment"
+    },
+    "count": {
+      "releases": "{n} release | {n} releases",
+      "works": "{n} œuvre | {n} œuvres",
+      "live": "{n} essaim vivant | {n} essaims vivants"
+    },
+    "loadMore": "Charger {n} de plus",
+    "defaults": {
+      "save": "Faire de ces filtres mon réglage",
+      "saved": "Réglage enregistré : le catalogue s’ouvrira ainsi",
+      "active": "Vos réglages",
+      "clear": "Retirer mes réglages",
+      "cleared": "Réglages retirés",
+      "failed": "Le réglage n’a pas pu être enregistré",
+      "hint": "Le catalogue s’ouvrira avec ces filtres, sur tous vos appareils"
     }
   },
   "users": {
@@ -1592,7 +1998,9 @@
         "inappropriate": "Contenu inapproprié",
         "harassment": "Harcèlement ou abus",
         "other": "Autre — voir détails ci-dessous",
-        "otherShort": "Autre"
+        "otherShort": "Autre",
+        "wrongMetadata": "Fiche de l'œuvre incorrecte — le film ou la série ne correspond pas à la release",
+        "wrongMetadataShort": "Fiche incorrecte"
       },
       "toasts": {
         "submitted": "Signalement envoyé avec succès"
@@ -1859,7 +2267,8 @@
       "noMatch": "Aucune section ne correspond.",
       "closeMenu": "Fermer le menu d'administration",
       "audit": "Journal d'audit",
-      "inviteTree": "Arbre d'invitations"
+      "inviteTree": "Arbre d'invitations",
+      "searchMisses": "Recherches vaines"
     },
     "descriptions": {
       "dashboard": "Configuration du tracker et gestion des nœuds",
@@ -1884,7 +2293,8 @@
       "federationTaxonomy": "Faire correspondre les slugs de catégorie des partenaires à vos propres catégories",
       "listingTemplates": "Choisir les mises en page de fiche proposées à tous les membres dans l'assistant d'upload.",
       "audit": "Chaque changement fait depuis la console du personnel — qui, quoi, quand.",
-      "inviteTree": "Qui s'est porté garant d'un membre, et qui ce membre a fait entrer."
+      "inviteTree": "Qui s'est porté garant d'un membre, et qui ce membre a fait entrer.",
+      "searchMisses": "Ce que les membres cherchent sans trouver"
     },
     "taxonomy": {
       "confirmRemove": {
@@ -2506,6 +2916,16 @@
         "saveFailed": "Échec de l'enregistrement de la catégorie",
         "deleteFailed": "Échec de la suppression de la catégorie",
         "seedFailed": "Échec de l'initialisation des catégories"
+      },
+      "merge": {
+        "action": "Fusionner",
+        "hint": "Fondre cette catégorie dans une autre",
+        "title": "Fusionner deux catégories",
+        "into": "Fusionner « {from} » dans :",
+        "confirm": "Tout ce qui est classé dans « {from} » passera dans « {into} », puis « {from} » sera supprimée. Cette action ne se défait pas.",
+        "cancel": "Annuler",
+        "done": "{n} torrent(s) déplacé(s) dans « {into} »",
+        "failed": "La fusion a échoué"
       }
     },
     "bonusRules": {
@@ -3956,7 +4376,41 @@
       },
       "fuzzy": "Tolérance aux fautes de frappe",
       "fuzzyLabel": "Rattraper les fautes de frappe",
-      "fuzzyHint": "Quand la recherche ne trouve rien, une seconde passe cherche les titres approchants — « crimsen » retrouve « Crimson ». Elle ne s’exécute que face à une page vide, mais coûte environ dix fois une recherche normale. À couper si le catalogue devient trop gros ou le serveur trop chargé."
+      "fuzzyHint": "Quand la recherche ne trouve rien, une seconde passe cherche les titres approchants — « crimsen » retrouve « Crimson ». Elle ne s’exécute que face à une page vide, mais coûte environ dix fois une recherche normale. À couper si le catalogue devient trop gros ou le serveur trop chargé.",
+      "catalogue": {
+        "view": "Vue à l’arrivée",
+        "viewHint": "Ce que les membres voient en ouvrant le catalogue sans filtre.",
+        "sort": "Tri par défaut",
+        "sortHint": "« Automatique » : la pertinence dès qu’un texte est tapé, les nouveautés sinon.",
+        "pageSize": "Résultats par page",
+        "pageSizeHint": "De 10 à 50 ; « Charger plus » ajoute autant à chaque fois.",
+        "facets": "Facettes du rail",
+        "facetsHint": "Les familles de filtres proposées à gauche du catalogue.",
+        "views": {
+          "grouped": "Œuvres",
+          "simple": "Releases"
+        },
+        "sorts": {
+          "auto": "Automatique",
+          "age": "Nouveautés",
+          "name": "Nom",
+          "size": "Taille",
+          "seeders": "Seeders",
+          "leechers": "Leechers",
+          "completed": "Complétés"
+        },
+        "facetNames": {
+          "category": "Catégorie",
+          "resolution": "Résolution",
+          "source": "Source",
+          "codec": "Codec",
+          "language": "Langue",
+          "hdr": "HDR",
+          "audio": "Audio",
+          "year": "Année",
+          "options": "Options"
+        }
+      }
     },
     "messaging": {
       "title": "Messagerie",
@@ -4149,6 +4603,36 @@
       "secretsKept": "Laissez un champ de mot de passe vide pour conserver celui déjà enregistré.",
       "faultLead": "La dernière tentative a échoué :",
       "testWhen": "Disponible quand le bot est dans le canal."
+    },
+    "hnrSettings": {
+      "title": "Hit & Run",
+      "description": "Une release prise doit être partagée un temps minimum. Passé le délai de grâce sans l'atteindre, elle est signalée en Hit & Run sur le compte du membre. Le seuil est figé sur chaque téléchargement au moment du clic : le changer ne rejuge pas les téléchargements passés.",
+      "enabled": "Suivi du Hit & Run",
+      "enabledHint": "Désactivé, aucune obligation n'est créée et rien n'est jamais signalé.",
+      "on": "Activé",
+      "off": "Désactivé",
+      "requiredHours": "Seuil de partage",
+      "requiredHint": "Le temps de seed exigé par release, en heures. C'est ce que la fiche annonce avant le téléchargement : « vous engage à N h de partage ». Zéro : aucune obligation.",
+      "graceHours": "Délai de grâce",
+      "graceHint": "Le temps laissé après le téléchargement avant qu'une release en dessous du seuil soit signalée.",
+      "hoursLabel": "heures",
+      "save": "Enregistrer",
+      "saved": "Enregistré"
+    },
+    "searchMisses": {
+      "title": "Recherches sans résultat",
+      "description": "Ce que les membres ont cherché sans rien trouver, les plus fréquentes d’abord. Une ligne traitée s’efface ; « Créer une demande » ouvre le formulaire avec le texte.",
+      "query": "Recherche",
+      "count": "Fois",
+      "first": "Première fois",
+      "last": "Dernière fois",
+      "delete": "Effacer cette ligne",
+      "clearAll": "Tout effacer",
+      "clearAllConfirm": "La liste repart de zéro. Les prochaines recherches sans résultat la rempliront de nouveau.",
+      "empty": "Aucune recherche sans résultat pour l’instant.",
+      "request": "Créer une demande",
+      "search": "Rejouer la recherche",
+      "failed": "L’opération a échoué"
     }
   },
   "mod": {
diff --git a/apps/web/nuxt.config.ts b/apps/web/nuxt.config.ts
index f979d6e2..e419e8ca 100644
--- a/apps/web/nuxt.config.ts
+++ b/apps/web/nuxt.config.ts
@@ -569,6 +569,21 @@ export default defineNuxtConfig({
   app: {
     head: {
       title: 'Trackarr',
+      /*
+       * `lang` ICI et pas seulement dans `app.vue`.
+       *
+       * Il était absent : `document.documentElement.lang` rendait une chaîne
+       * VIDE, sur un site qui sert deux langues. C'est un échec WCAG 3.1.1 de
+       * niveau A — un lecteur d'écran ne sait pas quelle voix employer, et un
+       * titre français se prononce à l'anglaise.
+       *
+       * `app.head` plutôt que `useHead` seul, pour la raison que le script du
+       * thème documente juste en dessous et qui a déjà mordu deux fois :
+       * `useHead` dans `app.vue` ne tourne PAS dans la construction statique.
+       * Ceci est le plancher présent dans le HTML des deux formes ; `app.vue`
+       * le remplace par la langue réelle du membre dès que le bundle démarre.
+       */
+      htmlAttrs: { lang: 'en' },
       meta: [
         { name: 'description', content: 'High-performance BitTorrent tracker' },
       ],
diff --git a/apps/web/server/routes/_media/sample.get.ts b/apps/web/server/routes/_media/sample.get.ts
new file mode 100644
index 00000000..728e6746
--- /dev/null
+++ b/apps/web/server/routes/_media/sample.get.ts
@@ -0,0 +1,120 @@
+import { createError, defineEventHandler, getHeader, getQuery, getRequestIP, setHeader } from 'h3';
+
+/**
+ * Un pixel d'affiche, pour la couleur de l'œuvre.
+ *
+ * Le héros de la fiche échantillonne l'affiche sur une toile pour teinter son
+ * décor. Les CDN d'affiches n'envoient pas d'en-tête CORS (mesuré sur TMDB :
+ * en mode `anonymous` l'image ne charge pas, et sans lui la toile est
+ * souillée) ; l'image passe donc par ici, même origine, et la toile reste
+ * lisible.
+ *
+ * Ce n'est PAS un relais d'images, et la revue a resserré chaque maille :
+ *
+ *   - trois hôtes connus, HTTPS, port par défaut, sans identifiants dans l'URL,
+ *     aucune redirection suivie ;
+ *   - seulement depuis nos pages : `Sec-Fetch-Site: same-origin` ET
+ *     `Sec-Fetch-Dest: image` sont EXIGÉS — un client sans ces en-têtes (curl,
+ *     une navigation directe, un vieux Safari) reçoit 403 et la fiche reste
+ *     simplement sans teinte ;
+ *   - des formats matriciels uniquement : un SVG servi depuis notre origine et
+ *     ouvert comme document exécuterait ses scripts chez nous ;
+ *   - 400 Ko au plus, comptés PENDANT la lecture — un flux sans
+ *     `content-length` ne peut pas remplir la mémoire avant la vérification ;
+ *   - quatre secondes, une CSP qui interdit tout au document servi, et une
+ *     limite par adresse pour que personne ne fasse marteler les CDN par ce
+ *     serveur.
+ *
+ * Mis en cache un jour : une affiche ne change pas.
+ */
+const HOSTS = new Set(['image.tmdb.org', 'images.igdb.com', 'covers.openlibrary.org']);
+const RASTER = new Set(['image/jpeg', 'image/png', 'image/webp', 'image/gif', 'image/avif']);
+const MAX_BYTES = 400 * 1024;
+const TIMEOUT_MS = 4000;
+
+/** 60 échantillons par minute et par adresse : une fiche en demande un. */
+const RATE_WINDOW_MS = 60_000;
+const RATE_MAX = 60;
+const hits = new Map<string, number[]>();
+function overQuota(ip: string): boolean {
+  const now = Date.now();
+  const recent = (hits.get(ip) ?? []).filter((t) => now - t < RATE_WINDOW_MS);
+  recent.push(now);
+  hits.set(ip, recent);
+  // La table ne garde que les adresses actives : au-delà de mille, on élague.
+  if (hits.size > 1000) {
+    for (const [k, v] of hits) if (v.every((t) => now - t >= RATE_WINDOW_MS)) hits.delete(k);
+  }
+  return recent.length > RATE_MAX;
+}
+
+export default defineEventHandler(async (event) => {
+  if (getHeader(event, 'sec-fetch-site') !== 'same-origin' || getHeader(event, 'sec-fetch-dest') !== 'image') {
+    throw createError({ statusCode: 403, statusMessage: 'Forbidden' });
+  }
+  const ip = getRequestIP(event, { xForwardedFor: true }) ?? 'unknown';
+  if (overQuota(ip)) throw createError({ statusCode: 429, statusMessage: 'Too many requests' });
+
+  const raw = String(getQuery(event).src ?? '');
+  let url: URL;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw createError({ statusCode: 400, statusMessage: 'Bad source' });
+  }
+  if (
+    url.protocol !== 'https:' ||
+    !HOSTS.has(url.hostname) ||
+    url.port !== '' ||
+    url.username !== '' ||
+    url.password !== ''
+  ) {
+    throw createError({ statusCode: 400, statusMessage: 'Bad source' });
+  }
+
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), TIMEOUT_MS);
+  try {
+    let res: Response;
+    try {
+      res = await fetch(url, { signal: ctrl.signal, redirect: 'error', headers: { accept: 'image/*' } });
+    } catch {
+      throw createError({ statusCode: 502, statusMessage: 'Upstream unavailable' });
+    }
+    const type = (res.headers.get('content-type') ?? '').split(';')[0]!.trim().toLowerCase();
+    const declared = Number(res.headers.get('content-length') ?? 0);
+    if (!res.ok || !RASTER.has(type) || declared > MAX_BYTES || !res.body) {
+      throw createError({ statusCode: 502, statusMessage: 'Not an image' });
+    }
+
+    // Lecture bornée : on s'arrête au premier octet de trop, sans attendre la
+    // fin du flux.
+    const chunks: Uint8Array[] = [];
+    let total = 0;
+    const reader = res.body.getReader();
+    try {
+      for (;;) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        total += value.byteLength;
+        if (total > MAX_BYTES) {
+          await reader.cancel();
+          throw createError({ statusCode: 502, statusMessage: 'Too large' });
+        }
+        chunks.push(value);
+      }
+    } catch (err) {
+      // Le délai tombé pendant la lecture arrive ici en AbortError : un 504, pas un 500 avec sa pile.
+      if ((err as { statusCode?: number }).statusCode) throw err;
+      throw createError({ statusCode: 504, statusMessage: 'Upstream timeout' });
+    }
+
+    setHeader(event, 'content-type', type);
+    setHeader(event, 'cache-control', 'public, max-age=86400, immutable');
+    setHeader(event, 'x-content-type-options', 'nosniff');
+    setHeader(event, 'content-security-policy', "default-src 'none'; sandbox");
+    return Buffer.concat(chunks);
+  } finally {
+    clearTimeout(timer);
+  }
+});
diff --git a/apps/web/server/routes/api/[...path].ts b/apps/web/server/routes/api/[...path].ts
index bd835427..9aa3e387 100644
--- a/apps/web/server/routes/api/[...path].ts
+++ b/apps/web/server/routes/api/[...path].ts
@@ -108,6 +108,32 @@ export default defineEventHandler(async (event) => {
   ];
   const headers = getProxyRequestHeaders(event);
   for (const name of SPOOFABLE) delete (headers as Record<string, unknown>)[name];
+  /*
+   * Supprimer une clé ici ne retire rien : `proxyRequest` (h3) repart des
+   * en-têtes ORIGINAUX de la requête et n'y applique les nôtres que par `set`.
+   * Les en-têtes qui nomment un client sont donc posés VIDES, ce qui, lui,
+   * écrase la valeur du navigateur — l'API lit un en-tête vide comme absent.
+   * Les `x-forwarded-proto/host/port` gardent leur sort d'avant (passés tels
+   * quels) : l'origine WebAuthn derrière le proxy s'en sert.
+   */
+  for (const name of ['x-real-ip', 'forwarded', 'cf-connecting-ip', 'true-client-ip']) {
+    (headers as Record<string, string>)[name] = '';
+  }
+  /*
+   * L'ABSENCE d'en-tête est un contrat, pas un oubli.
+   *
+   * Une requête relayée pour un navigateur a un pair observé, donc elle repart
+   * avec `x-forwarded-for`. Une requête que le rendu serveur émet pour
+   * lui-même n'a pas de pair : elle repart SANS aucun en-tête de transfert, et
+   * c'est à cela que l'API la reconnaît (`isInternalOrigin`) pour ne pas la
+   * compter dans son détecteur d'abus — sinon quatre requêtes par page vue
+   * s'accumulent sur l'unique adresse de ce conteneur et l'instance se bannit
+   * elle-même au bout de vingt-cinq pages en dix secondes.
+   *
+   * Donc : ne jamais poser un `x-forwarded-for` de repli ici. Poser une valeur
+   * quand il n'y a pas de pair remettrait tout le rendu serveur dans le
+   * compteur.
+   */
   const observed = getRequestIP(event, { xForwardedFor: false });
   if (observed) (headers as Record<string, string>)['x-forwarded-for'] = observed;
 
diff --git a/apps/web/test/catalogueLogic.test.ts b/apps/web/test/catalogueLogic.test.ts
new file mode 100644
index 00000000..0d6b67f6
--- /dev/null
+++ b/apps/web/test/catalogueLogic.test.ts
@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest';
+import { groupVersions, versionKey } from '../app/utils/releaseVersions';
+import { homeScope, scopesOf, unitsOf } from '../app/utils/workUnits';
+import { categoryRows, familyRows } from '../app/utils/catalogueFacets';
+
+describe('versions d’un même contenu', () => {
+  const w = { source: 'tmdb', id: 'tv/209867' };
+  it('regroupe même œuvre + même unité, la première en tête', () => {
+    const rows = [
+      { id: 'a', season: 1, episode: 9, work: w },
+      { id: 'b', season: 1, episode: 9, work: w },
+      { id: 'c', season: 1, episode: 10, work: w },
+    ];
+    const g = groupVersions(rows);
+    expect(g).toHaveLength(2);
+    expect(g[0]!.lead.id).toBe('a');
+    expect(g[0]!.others.map((r) => r.id)).toEqual(['b']);
+    expect(g[1]!.lead.id).toBe('c');
+  });
+  it('ne regroupe jamais sans œuvre connue', () => {
+    const rows = [{ id: 'a', season: 1, episode: 9, work: null }, { id: 'b', season: 1, episode: 9, work: null }];
+    expect(groupVersions(rows)).toHaveLength(2);
+    expect(versionKey(rows[0]!)).toBeNull();
+  });
+  it('un pack de saison et un épisode ne sont pas la même unité', () => {
+    const rows = [{ id: 'a', season: 1, episode: null, work: w }, { id: 'b', season: 1, episode: 9, work: w }];
+    expect(groupVersions(rows)).toHaveLength(2);
+  });
+});
+
+describe('découpes d’une œuvre', () => {
+  const scopes = [
+    { scope: 'integral' as const, units: 1, latest: '2026-01-01' },
+    { scope: 'episode' as const, units: 2, latest: '2026-03-01' },
+    { scope: 'season' as const, units: 1, latest: '2026-02-01' },
+    { scope: 'all' as const, units: 0, latest: '2026-02-01' },
+  ];
+  it('range épisode, saison, intégrale et retire ce qui est vide', () => {
+    expect(scopesOf(scopes).map((s) => s.scope)).toEqual(['episode', 'season', 'integral']);
+  });
+  it('met en avant la découpe du premier torrent du tri si elle existe', () => {
+    expect(homeScope({ scopes, firstScope: 'season', defaultScope: 'episode' })).toBe('season');
+    expect(homeScope({ scopes, firstScope: 'all', defaultScope: 'episode' })).toBe('episode');
+    expect(homeScope({ scopes: [] })).toBe('all');
+  });
+  it('découpe en unités selon la portée ouverte', () => {
+    const rows = [
+      { id: 'e10', season: 1, episode: 10 },
+      { id: 'e9', season: 1, episode: 9 },
+      { id: 'e9b', season: 1, episode: 9 },
+      { id: 's1', season: 1, episode: null },
+      { id: 'int', season: null, episode: null },
+    ];
+    const ep = unitsOf(rows.filter((r) => r.episode !== null), 'episode');
+    expect(ep.map((u) => u.key)).toEqual(['e1-10', 'e1-9']);
+    expect(ep[1]!.rows).toHaveLength(2);
+    const all = unitsOf(rows, 'all');
+    expect(all.map((u) => u.kind)).toEqual(['episode', 'episode', 'season', 'all']);
+    expect(unitsOf([rows[4]!], 'integral')[0]!.kind).toBe('integral');
+  });
+});
+
+describe('rail de facettes', () => {
+  it('les enfants comptent pour leur parent, les vides disparaissent, le coché reste', () => {
+    const cats = [
+      { id: 'p1', name: 'Séries', slug: 'series', parentId: null, subcategories: [{ id: 'c1', name: 'Anime', slug: 'anime', parentId: 'p1' }] },
+      { id: 'p2', name: 'Films', slug: 'films', parentId: null, subcategories: [] },
+      { id: 'p3', name: 'Livres', slug: 'livres', parentId: null, subcategories: [] },
+    ];
+    const rows = categoryRows(cats, [{ id: 'c1', count: 4 }, { id: 'p1', count: 1 }, { id: 'p2', count: 2 }], 'p3');
+    expect(rows.map((r) => [r.id, r.count])).toEqual([['p1', 5], ['p2', 2], ['p3', 0]]);
+    expect(rows[0]!.kids).toEqual([{ id: 'c1', name: 'Anime', count: 4 }]);
+  });
+  it('une famille qui a posé un groupe lit les comptes sans elle-même', () => {
+    const facets = {
+      tags: [{ slug: '1080p', name: '1080p', count: 3 }, { slug: 'x265', name: 'x265', count: 2 }],
+      tagsByGroup: { '0': [{ slug: '1080p', name: '1080p', count: 17 }, { slug: '2160p', name: '2160p', count: 3 }] },
+    };
+    const isRes = (s: string) => /p$/.test(s);
+    expect(familyRows(facets, 0, isRes).map((r) => r.slug)).toEqual(['1080p', '2160p']);
+    expect(familyRows(facets, -1, isRes).map((r) => r.slug)).toEqual(['1080p']);
+  });
+});
diff --git a/apps/web/test/chipTagOverlap.test.ts b/apps/web/test/chipTagOverlap.test.ts
new file mode 100644
index 00000000..ec06f27a
--- /dev/null
+++ b/apps/web/test/chipTagOverlap.test.ts
@@ -0,0 +1,117 @@
+import { describe, expect, it } from 'vitest';
+import {
+  chipAtoms,
+  tagForChip,
+  tagsBeyondChips,
+} from '../app/utils/chipTagOverlap';
+import { releaseChips } from '../app/utils/releaseChips';
+
+/**
+ * Ce que le filtre doit garder, et surtout ce qu'il ne doit PAS manger.
+ *
+ * La logique est du jugement — décider que deux mots désignent le même fait —
+ * et un jugement non testé dérive. Les cas ci-dessous viennent tous du
+ * catalogue de test réel, pas d'une invention : `x264` contre `AVC` neuf fois,
+ * `AAC` onze fois, `MULTI` là où la pastille dit autre chose.
+ */
+
+const tag = (name: string) => ({ name, slug: name.toLowerCase(), id: name });
+
+describe('tagsBeyondChips', () => {
+  const nom =
+    'Sousou.no.Frieren.S01E09.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws';
+
+  it('retire ce que la pastille dit mot pour mot', () => {
+    const reste = tagsBeyondChips(nom, [tag('1080p'), tag('WEB-DL'), tag('VOSTFR')]);
+    expect(reste).toEqual([]);
+  });
+
+  it('retire l’encodeur quand la pastille affiche sa norme', () => {
+    // La pastille dit `AVC` ; le tag dit `x264`. Même fait.
+    expect(releaseChips(nom).codec).toBe('AVC');
+    expect(tagsBeyondChips(nom, [tag('x264')])).toEqual([]);
+    expect(tagsBeyondChips(nom, [tag('x265')]).map((t) => t.name)).toEqual(['x265']);
+  });
+
+  it('retire le codec audio maintenant que la pastille le compose', () => {
+    // `AAC 2.0` en une fente : le tag `AAC` comme le tag `2.0` sont couverts.
+    expect(releaseChips(nom).audio).toBe('AAC 2.0');
+    expect(tagsBeyondChips(nom, [tag('AAC'), tag('2.0')])).toEqual([]);
+  });
+
+  it('GARDE ce qu’aucune pastille ne dit', () => {
+    const reste = tagsBeyondChips(nom, [tag('anime'), tag('saison-complete')]);
+    expect(reste.map((t) => t.name)).toEqual(['anime', 'saison-complete']);
+  });
+
+  it('ne confond pas deux langues qui ne disent pas la même chose', () => {
+    // La pastille dit `VOSTFR` — des sous-titres. `MULTI` dit plusieurs pistes
+    // AUDIO. Les rapprocher parce qu'ils occupent la même fente ferait
+    // disparaître une information réelle.
+    expect(tagsBeyondChips(nom, [tag('MULTI')]).map((t) => t.name)).toEqual(['MULTI']);
+  });
+
+  it('couvre chaque moitié d’une langue composée', () => {
+    const multi = 'Cats.Eye.S01.MULTi.VFF.1080p.BluRay.x264-KAZETV';
+    expect(releaseChips(multi).language).toBe('MULTI.VFF');
+    expect(tagsBeyondChips(multi, [tag('MULTI'), tag('VFF')])).toEqual([]);
+  });
+
+  it('rend tout quand il n’y a pas de nom à analyser', () => {
+    expect(tagsBeyondChips(null, [tag('1080p')]).map((t) => t.name)).toEqual(['1080p']);
+    expect(tagsBeyondChips('', [tag('1080p')]).map((t) => t.name)).toEqual(['1080p']);
+  });
+
+  it('rend une liste vide plutôt que `null`', () => {
+    expect(tagsBeyondChips('x', null)).toEqual([]);
+    expect(tagsBeyondChips('x', [])).toEqual([]);
+  });
+});
+
+describe('chipAtoms', () => {
+  it('ne découpe pas les canaux sur le point', () => {
+    // `2.0` découpé donnerait les atomes `2` et `0`, qui rendraient redondant
+    // n'importe quel tag nommé « 2 ».
+    const atoms = chipAtoms(
+      releaseChips('X.1080p.WEB-DL.AAC.2.0.H.264-GRP'),
+    );
+    expect(atoms.has('2.0')).toBe(true);
+    expect(atoms.has('0')).toBe(false);
+  });
+});
+
+describe('tagForChip', () => {
+  const tags = [tag('WEB-DL'), tag('x264'), tag('AAC')];
+
+  it('relie une pastille au tag de même nom', () => {
+    expect(tagForChip('WEB-DL', tags)?.slug).toBe('web-dl');
+  });
+
+  it('relie une pastille au tag qui la nomme autrement', () => {
+    expect(tagForChip('AVC', tags)?.name).toBe('x264');
+  });
+
+  it('relie chaque moitié d’une pastille composée', () => {
+    expect(tagForChip('AAC 2.0', tags)?.name).toBe('AAC');
+  });
+
+  it('ne fabrique pas de lien quand aucun tag ne correspond', () => {
+    expect(tagForChip('2160p', tags)).toBeNull();
+    expect(tagForChip(null, tags)).toBeNull();
+    expect(tagForChip('WEB-DL', [])).toBeNull();
+  });
+});
+
+describe('les codecs voisins ne sont pas confondus', () => {
+  it('ne replie pas DivX ni XviD sur AVC', () => {
+    // MPEG-4 ASP, pas H.264 : avec l'alias, une étiquette XviD posée à la main
+    // était reliée à une pastille AVC lue dans le nom, donc masquée comme
+    // « redondante » alors qu'elle dit autre chose.
+    const tags = [tag('XviD'), tag('x264')];
+    expect(tagForChip('AVC', tags)?.name).toBe('x264');
+    expect(tagForChip('XviD', tags)?.name).toBe('XviD');
+    // Une pastille AVC ne doit plus revendiquer l'étiquette XviD.
+    expect(tagForChip('AVC', [tag('XviD')])).toBeNull();
+    expect(tagForChip('AVC', [tag('DivX')])).toBeNull();
+  });
+});
diff --git a/apps/web/test/duration.test.ts b/apps/web/test/duration.test.ts
new file mode 100644
index 00000000..afc67bf2
--- /dev/null
+++ b/apps/web/test/duration.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { formatDurationSeconds } from '../app/utils/duration';
+
+/**
+ * La durée d'une obligation de seed, telle qu'elle se lit.
+ *
+ * En heures sous quatre jours, parce que le site compte en heures (72 h) et
+ * que « 2 j 13 h » demande une soustraction que « 61 h » ne demande pas.
+ * Au-delà, les jours reprennent — et c'est là que l'arrondi mordait.
+ */
+describe('formatDurationSeconds', () => {
+  it('reste en heures sous quatre jours', () => {
+    expect(formatDurationSeconds(72 * 3600, 'fr')).toContain('72');
+    expect(formatDurationSeconds(3600, 'fr')).toContain('1');
+    // Sous l'heure, des minutes.
+    expect(formatDurationSeconds(600, 'fr')).toContain('10');
+  });
+
+  it('ne rend jamais « 24 h » à côté des jours', () => {
+    // 4 j 23 h 50 arrondissait l'heure à 24 : un jour de plus, pas une 24ᵉ heure.
+    const s = formatDurationSeconds(4 * 86400 + 23 * 3600 + 50 * 60, 'fr');
+    expect(s).not.toMatch(/\b24\b/);
+    expect(s).toMatch(/\b5\b/);
+    // Et l'heure disparaît quand elle vaut zéro.
+    expect(formatDurationSeconds(5 * 86400, 'fr')).not.toMatch(/\b0\b/);
+  });
+
+  it('encaisse le zéro et le négatif sans rien inventer', () => {
+    expect(formatDurationSeconds(0, 'fr')).toContain('0');
+    expect(formatDurationSeconds(-500, 'fr')).toContain('0');
+  });
+});
diff --git a/apps/web/test/savedSearchLink.test.ts b/apps/web/test/savedSearchLink.test.ts
index 76432b3c..f336ca72 100644
--- a/apps/web/test/savedSearchLink.test.ts
+++ b/apps/web/test/savedSearchLink.test.ts
@@ -97,3 +97,50 @@ describe('savedSearchLink', () => {
     }
   });
 });
+
+/**
+ * Les critères que la branche s'est mise à STOCKER (saison, épisode, année,
+ * uploadeur, familles d'étiquettes) — et que le lien oubliait.
+ *
+ * Une alerte enregistrée comme « frieren S02 @lou » ouvrait la série entière,
+ * par tout le monde : le lien rejouait PLUS LARGE que ce que le membre avait
+ * demandé. La même panne que les noms d'API, en plus discrète, puisqu'il
+ * s'affichait bien des résultats.
+ */
+function paramsReadByTokens(): Set<string> {
+  const src = readFileSync(new URL('../app/utils/searchTokens.ts', import.meta.url), 'utf8');
+  const found = new Set<string>();
+  for (const m of src.matchAll(/\bquery\.([a-zA-Z]+)\b/g)) found.add(m[1]!);
+  return found;
+}
+
+describe('savedSearchLink — les critères de la barre', () => {
+  it('rejoue la saison, l’épisode, l’année et les familles d’étiquettes', () => {
+    const q = new URL(
+      savedSearchLink({ query: 'frieren', tagGroups: 'hevc,x265;1080p', season: 2, episode: 4, year: 2024 }),
+      'http://localhost',
+    ).searchParams;
+    // Un mot par famille, et ce mot EST la liste : la barre la relit telle quelle.
+    expect(q.get('tk')).toBe('hevc,x265 1080p');
+    expect(q.get('se')).toBe('2');
+    expect(q.get('ep')).toBe('4');
+    expect(q.get('y')).toBe('2024');
+  });
+
+  it('n’émet que ce qui est stocké', () => {
+    expect(savedSearchLink({ season: 0 })).toBe('/torrents?se=0');
+    const q = new URL(savedSearchLink({ query: 'x', tagGroups: ';;' }), 'http://localhost').searchParams;
+    expect(q.has('tk')).toBe(false);
+    expect(new URL(savedSearchLink({ query: 'x' }), 'http://localhost').searchParams.has('se')).toBe(false);
+  });
+
+  it('chacun de ces paramètres est lu au chargement de la page', () => {
+    // `tk`/`se`/`ep`/`y` n'entrent pas par `route.query.X` mais par
+    // `tokensFromQuery(route.query)` : c'est là qu'il faut les chercher.
+    const read = paramsReadByTokens();
+    expect(read.size).toBeGreaterThan(3);
+    for (const name of ['tk', 'se', 'ep', 'y']) {
+      expect(read, `la barre ne lit jamais « ${name} »`).toContain(name);
+    }
+  });
+});
diff --git a/apps/web/test/searchTokens.test.ts b/apps/web/test/searchTokens.test.ts
new file mode 100644
index 00000000..b4a8c473
--- /dev/null
+++ b/apps/web/test/searchTokens.test.ts
@@ -0,0 +1,154 @@
+import { describe, expect, it } from 'vitest';
+import {
+  hasSlug,
+  kindOfSlug,
+  tagGroupIndex,
+  toggleSlug,
+  parseSearchInput,
+  tokensFromQuery,
+  tokensToQuery,
+  tokensToUrl,
+  tokenLabel,
+  tokenize,
+} from '../app/utils/searchTokens';
+
+describe('searchTokens', () => {
+  it('sépare le texte cherché des qualificatifs', () => {
+    const { tokens, text } = parseSearchInput('frieren 1080p x265 vostfr s02e04 2023 @loli');
+    expect(text).toBe('frieren');
+    expect(tokens.map((t) => t.kind).sort()).toEqual(
+      ['codec', 'episode', 'language', 'resolution', 'season', 'uploader', 'year'].sort(),
+    );
+  });
+
+  it('un codec porte tous ses synonymes, en OU', () => {
+    const t = tokenize('x265')!;
+    expect(t.kind).toBe('codec');
+    expect(t.slugs).toEqual(expect.arrayContaining(['x265', 'hevc']));
+  });
+
+  it('deux jetons d’une même famille ne font qu’un groupe', () => {
+    const { tokens } = parseSearchInput('1080p 2160p');
+    expect(tokens).toHaveLength(1);
+    expect(tokens[0]!.slugs).toEqual(expect.arrayContaining(['1080p', '2160p']));
+    expect(tokensToQuery(tokens).tagGroups).toContain('1080p');
+  });
+
+  it('les familles se croisent en ET dans tagGroups', () => {
+    const { tokens } = parseSearchInput('hevc 1080p');
+    const q = tokensToQuery(tokens).tagGroups!;
+    expect(q.split(';')).toHaveLength(2);
+  });
+
+  it('un numéro ne vaut qu’une fois, le dernier gagne', () => {
+    const { tokens } = parseSearchInput('2019 2023');
+    expect(tokens.filter((t) => t.kind === 'year')).toHaveLength(1);
+    expect(tokensToQuery(tokens).year).toBe('2023');
+  });
+
+  it('s02e04 devient une saison et un épisode', () => {
+    const q = tokensToQuery(parseSearchInput('s02e04').tokens);
+    expect(q.season).toBe('2');
+    expect(q.episode).toBe('4');
+  });
+
+  it('une année hors 19xx/20xx, un mot ordinaire ou un nombre nu restent du texte', () => {
+    expect(tokenize('1850')).toBeNull();
+    expect(tokenize('frieren')).toBeNull();
+    expect(tokenize('42')).toBeNull();
+    expect(tokenize('@')).toBeNull();
+  });
+
+  it('l’URL est réversible : le mot tapé, pas ses slugs', () => {
+    const { tokens } = parseSearchInput('x265 vostfr s02 e04 2023 @loli');
+    const url = tokensToUrl(tokens);
+    expect(url).toEqual({ tk: 'x265 vostfr', se: '2', ep: '4', y: '2023', u: 'loli' });
+    const back = tokensFromQuery(url);
+    expect(tokensToQuery(back)).toEqual(tokensToQuery(tokens));
+    expect(back.map(tokenLabel)).toEqual(['x265', 'vostfr', 'S02', 'E04', '2023', '@loli']);
+  });
+
+  it('un lien TMDb devient un jeton d’identifiant', () => {
+    const t = tokenize('https://www.themoviedb.org/tv/209867-sousou-no-frieren');
+    expect(t?.kind).toBe('tmdb');
+  });
+
+  it('connaît la famille d’un slug, et l’ignore quand il n’en a pas', () => {
+    expect(kindOfSlug('hevc')).toBe('codec');
+    expect(kindOfSlug('2-0')).toBe('audio');
+    expect(kindOfSlug('dolby-vision')).toBe('hdr');
+    expect(kindOfSlug('proper')).toBeNull();
+  });
+
+  it('coche et décoche un slug depuis le rail, un jeton par famille', () => {
+    let tokens = toggleSlug([], 'codec', 'hevc');
+    tokens = toggleSlug(tokens, 'codec', 'x264');
+    expect(tokens).toHaveLength(1);
+    expect(tokens[0]!.slugs).toEqual(['hevc', 'x264']);
+    expect(hasSlug(tokens, 'x264')).toBe(true);
+    tokens = toggleSlug(tokens, 'codec', 'hevc');
+    expect(tokens[0]!.slugs).toEqual(['x264']);
+    tokens = toggleSlug(tokens, 'codec', 'x264');
+    expect(tokens).toEqual([]);
+  });
+
+  it('un slug coché survit à l’URL même sans alias', () => {
+    const tokens = toggleSlug([], 'audio', '2-0');
+    const back = tokensFromQuery(tokensToUrl(tokens));
+    expect(back).toHaveLength(1);
+    expect(back[0]!.kind).toBe('audio');
+    expect(back[0]!.slugs).toEqual(['2-0']);
+  });
+
+  it('retrouve la place du groupe d’une famille dans tagGroups', () => {
+    const { tokens } = parseSearchInput('vostfr hevc s01');
+    const groups = tokensToQuery(tokens).tagGroups!.split(';');
+    expect(groups[tagGroupIndex(tokens, 'language')]).toContain('vostfr');
+    expect(groups[tagGroupIndex(tokens, 'codec')]).toContain('hevc');
+    expect(tagGroupIndex(tokens, 'resolution')).toBe(-1);
+  });
+
+  it('ignore les paramètres d’URL mal formés', () => {
+    expect(tokensFromQuery({ se: 'abc', ep: '99999', y: '1850', u: 'a b' })).toEqual([]);
+  });
+});
+
+describe('le rail et l’URL disent la même chose', () => {
+  it('garde exactement les slugs cochés après un aller-retour par l’URL', () => {
+    // Un mot tapé étend sa famille : x265 vaut aussi hevc, h265, h-265.
+    const typed = parseSearchInput('x265').tokens;
+    const family = typed[0]!.slugs!;
+    expect(family.length).toBeGreaterThan(1);
+    // Décocher un synonyme depuis le rail.
+    const pruned = toggleSlug(typed, 'codec', family[1]!);
+    const kept = pruned[0]!.slugs!;
+    expect(kept).not.toContain(family[1]);
+    // L'URL, puis le rechargement : la liste doit revenir telle quelle.
+    const back = tokensFromQuery(tokensToUrl(pruned));
+    expect(back[0]!.slugs).toEqual(kept);
+  });
+
+  it('rend la case cochable et décochable sans effet de bord', () => {
+    let tokens = toggleSlug([], 'resolution', '1080p');
+    expect(hasSlug(tokens, '1080p')).toBe(true);
+    tokens = toggleSlug(tokens, 'resolution', '2160p');
+    expect(tokens).toHaveLength(1);
+    expect(tokens[0]!.slugs).toEqual(['1080p', '2160p']);
+    // L'URL porte UN mot, la liste exacte.
+    expect(tokensToUrl(tokens).tk).toBe('1080p,2160p');
+    expect(tokensFromQuery({ tk: '1080p,2160p' })[0]!.slugs).toEqual(['1080p', '2160p']);
+    // Tout décocher retire la puce.
+    tokens = toggleSlug(toggleSlug(tokens, 'resolution', '1080p'), 'resolution', '2160p');
+    expect(tokens).toHaveLength(0);
+  });
+
+  it('affiche une liste explicite lisiblement', () => {
+    const [tok] = tokensFromQuery({ tk: 'hevc,x265' });
+    expect(tokenLabel(tok!)).toBe('hevc · x265');
+  });
+
+  it('ignore une liste dont les membres ne sont pas d’une même famille', () => {
+    // `1080p,hevc` mélange résolution et codec : ce n'est pas une liste de rail.
+    expect(tokensFromQuery({ tk: '1080p,hevc' })).toHaveLength(0);
+  });
+});
diff --git a/apps/web/test/versionMarkers.test.ts b/apps/web/test/versionMarkers.test.ts
new file mode 100644
index 00000000..dd6a5078
--- /dev/null
+++ b/apps/web/test/versionMarkers.test.ts
@@ -0,0 +1,239 @@
+import { describe, expect, it } from 'vitest';
+import {
+  assignVersionMarkers,
+  releaseGroup,
+  releaseTags,
+  type VersionFacts,
+} from '~/utils/versionMarkers';
+
+/*
+ * Les repères de version, mesurés sur le catalogue de test.
+ *
+ * Tous les noms ci-dessous sont recopiés de la base — c'est la seule façon de
+ * vérifier ce qui compte réellement, à savoir ce que l'analyseur de noms tire
+ * de VRAIS noms de release. Un jeu de noms inventés confirme l'algorithme et
+ * rate le vocabulaire : `AAC.2.0` ne produit pas le jeton `AAC` mais `2.0`,
+ * `DDP2.0` n'en produit aucun, et les deux comptent pour « Compat ».
+ */
+
+function facts(name: string, size: number): VersionFacts {
+  return { size, tags: releaseTags(name) };
+}
+
+const GIB = 1024 ** 3;
+
+describe('assignVersionMarkers', () => {
+  it("ne pose aucun repère sur une version seule : il n'y a rien à arbitrer", () => {
+    expect(
+      assignVersionMarkers([
+        facts('Cats.Eye.S01.MULTi.1080p.BluRay.x264-KAZETV', 56306370355),
+      ]),
+    ).toEqual([null]);
+  });
+
+  /*
+   * Les quatre versions de `Sousou.no.Frieren.S01E09` — l'unité que le tracker
+   * de référence affiche, et le cas pour lequel la fonctionnalité existe.
+   */
+  it('sépare les quatre versions d’un même épisode', () => {
+    const markers = assignVersionMarkers([
+      facts('Sousou.no.Frieren.S01E09.MULTi.2160p.WEB-DL.DDP5.1.HDR.HEVC-FLUX', 4509715660),
+      facts('Sousou.no.Frieren.S01E09.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws', 1476395008),
+      facts('Sousou.no.Frieren.S01E09.VF.1080p.WEB-DL.EAC3.2.0.H.264-QCTeam', 1395864371),
+      facts('Sousou.no.Frieren.S01E09.VOSTFR.1080p.WEBRip.AAC.2.0.x265-NOTAG', 734003200),
+    ]);
+    expect(markers).toEqual([
+      // 2160p + HDR : seule sur ces deux axes.
+      'imageMax',
+      // H.264, pas de piste lossless, 1080p — et la plus grosse des deux
+      // candidates, donc la meilleure des versions qui lisent partout.
+      'compat',
+      // Également compatible, mais le repère ne se pose qu'une fois.
+      null,
+      // 0,73 Gio contre 1,40 pour la suivante : l'écart est réel.
+      'light',
+    ]);
+  });
+
+  /*
+   * La panne qui a motivé ce fichier, à l'intérieur d'une unité cette fois :
+   * le WEB-DL pèse presque le double du BluRay et n'a pas la meilleure image.
+   */
+  it('couronne la source, pas la taille', () => {
+    const webdl = facts(
+      'Sousou.no.Frieren.S01.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws',
+      42924507136,
+    );
+    const bluray = facts(
+      'Sousou.no.Frieren.S01.MULTi.1080p.BluRay.x265.10bit.FLAC.2.0-KAWAII',
+      22412347300,
+    );
+    expect(assignVersionMarkers([webdl, bluray])).toEqual([
+      'compat',
+      'imageMax',
+    ]);
+  });
+
+  it('ne reporte pas « Léger » sur la deuxième plus petite', () => {
+    // Les trois éditions de Dune du catalogue. « Léger » saute : 18,2536 et
+    // 18,2547 Gio ne se distinguent pas, et la plus petite reste la deuxième
+    // plus grosse du lot. « Son d'origine » saute aussi, pour l'autre raison —
+    // les TROIS ont une piste intacte (TrueHD, DTS-HD, DTS-HD), donc le repère
+    // n'aiderait personne à choisir.
+    const markers = assignVersionMarkers([
+      facts('Dune.Part.Two.2024.2160p.UHD.BluRay.REMUX.DV.HDR.HEVC.TrueHD', 88627884028),
+      facts('Dune.Part.Two.2024.PROPER.1080p.BluRay.x264.DTS-HD.MA.5.1-Sb', 18254663696),
+      facts('Dune.Part.Two.2024.1080p.BluRay.x264.DTS-HD.MA.5.1-SbR', 18253615104),
+    ]);
+    expect(markers).toEqual(['imageMax', null, null]);
+  });
+
+  it('descend « Son d’origine » sur la meilleure ligne encore libre', () => {
+    // Le REMUX gagne l'image et porte AUSSI la piste d'origine. Le repère ne
+    // disparaît pas pour autant : il descend au BluRay DTS-HD, qui l'a
+    // réellement. C'est ce qui distingue une PROPRIÉTÉ d'un extremum.
+    const markers = assignVersionMarkers([
+      facts('Dune.Part.Two.2024.2160p.UHD.BluRay.REMUX.DV.HDR.HEVC.TrueHD', 88 * GIB),
+      facts('Dune.Part.Two.2024.1080p.BluRay.x264.DTS-HD.MA.5.1-Sb', 18 * GIB),
+      facts('Dune.Part.Two.2024.1080p.WEB-DL.AAC.2.0.H.264-Nope', 5 * GIB),
+    ]);
+    // Et « Léger » saute : la plus petite porte déjà « Compat ».
+    expect(markers).toEqual(['imageMax', 'audioOriginal', 'compat']);
+  });
+
+  it("tait un repère que toutes les versions porteraient", () => {
+    // Les deux versions de l'épisode 10 : même résolution, même source, aucune
+    // piste lossless, toutes deux en H.264. Rien ne les sépare que la langue,
+    // qui a sa propre colonne — donc aucun repère, et 1,50 contre 1,61 Gio
+    // n'est pas un écart de taille.
+    const markers = assignVersionMarkers([
+      facts('Sousou.no.Frieren.S01E10.MULTi.1080p.WEB-DL.DDP2.0.H.264-VARYG', 1610612736),
+      facts('Sousou.no.Frieren.S01E10.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws', 1503238553),
+    ]);
+    expect(markers).toEqual([null, null]);
+  });
+
+  it('n’invente pas de meilleure image entre deux versions identiques', () => {
+    const markers = assignVersionMarkers([
+      facts('Some.Show.S01E01.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-A', 4 * GIB),
+      facts('Some.Show.S01E01.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-B', 2 * GIB),
+    ]);
+    // Aucune image « max » : les deux sont 1080p WEB-DL sans HDR. Seul l'écart
+    // de taille dit quelque chose.
+    expect(markers).toEqual([null, 'light']);
+  });
+
+  it('ne dit pas « lit partout » d’un 2160p H.264', () => {
+    const markers = assignVersionMarkers([
+      facts('Some.Movie.2024.2160p.WEB-DL.AAC.2.0.H.264-A', 40 * GIB),
+      facts('Some.Movie.2024.1080p.WEBRip.HEVC-B', 4 * GIB),
+    ]);
+    // Le 2160p prend l'image ; « Compat » n'est attribué à personne, le HEVC
+    // n'y ayant pas droit et le 2160p passant le plafond de résolution.
+    expect(markers).toEqual(['imageMax', 'light']);
+  });
+
+  it('ignore une taille inconnue plutôt que de la déclarer légère', () => {
+    const markers = assignVersionMarkers([
+      facts('Some.Movie.2024.1080p.BluRay.x264.DTS-HD.MA.5.1-A', 10 * GIB),
+      facts('Some.Movie.2024.1080p.BluRay.x264.AAC-B', 0),
+    ]);
+    expect(markers[1]).not.toBe('light');
+  });
+
+  it('survit à un nom que l’analyseur ne comprend pas', () => {
+    const markers = assignVersionMarkers([
+      { size: 1, tags: [] },
+      { size: 2, tags: [] },
+    ]);
+    // Rien à dire : aucune résolution, aucune source, aucun codec. Et la plus
+    // petite ne gagne pas « Léger » parce que 1 ⩽ 2 × 0,9 — elle le gagne,
+    // justement, et c'est la seule chose que deux tailles connues permettent
+    // d'affirmer.
+    expect(markers).toEqual(['light', null]);
+  });
+});
+
+describe('releaseTags', () => {
+  it('rend les jetons que les colonnes affichent', () => {
+    const tags = releaseTags(
+      'Sousou.no.Frieren.S01E09.MULTi.2160p.WEB-DL.DDP5.1.HDR.HEVC-FLUX',
+    );
+    expect(tags).toContain('2160p');
+    expect(tags).toContain('WEB-DL');
+    expect(tags).toContain('HDR');
+    expect(tags).toContain('HEVC');
+  });
+});
+
+describe('releaseGroup', () => {
+  /*
+   * Les quatre noms de l'unité `S01E09` plus l'intégrale, recopiés de la base :
+   * c'est la colonne qui départage deux versions que la langue, la résolution
+   * et la source égalisent toutes les trois.
+   */
+  it('rend le suffixe des vrais noms du catalogue', () => {
+    expect(
+      [
+        'Sousou.no.Frieren.S01E09.MULTi.2160p.WEB-DL.DDP5.1.HDR.HEVC-FLUX',
+        'Sousou.no.Frieren.S01E09.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws',
+        'Sousou.no.Frieren.S01E09.VF.1080p.WEB-DL.EAC3.2.0.H.264-QCTeam',
+        'Sousou.no.Frieren.S01E09.VOSTFR.1080p.WEBRip.AAC.2.0.x265-NOTAG',
+        'Sousou no Frieren - Integrale MULTi 1080p BluRay x265 10bit FLAC-KAWAII',
+        'Dune.Part.Two.2024.2160p.UHD.BluRay.REMUX.DV.HDR.HEVC.TrueHD.7.1.Atmos-FraMeSToR',
+      ].map(releaseGroup),
+    ).toEqual([
+      'FLUX',
+      'TsundereRaws',
+      'QCTeam',
+      'NOTAG',
+      'KAWAII',
+      'FraMeSToR',
+    ]);
+  });
+
+  it("ne prend pas la queue d'un titre pour un groupe", () => {
+    // Un chiffre seul et une lettre seule ne sont pas des groupes ; c'est le
+    // garde-fou que `stripGroup` n'a pas, parce qu'il n'en a pas besoin.
+    expect(releaseGroup('Kill.Bill.Vol-2')).toBeNull();
+    expect(releaseGroup('Some.Movie.2024.1080p.BluRay')).toBeNull();
+    expect(releaseGroup('Rec-A')).toBeNull();
+  });
+});
+
+describe('la borne est au composant, pas ici', () => {
+  /*
+   * Le contrat que `VersionsTable.vue` doit tenir, écrit noir sur blanc.
+   *
+   * Cette fonction ne SAIT pas ce qu'est une unité : donnée deux saisons, elle
+   * les compare, et le résultat est exactement le mensonge de départ — la
+   * saison 2 couronnée « Image max » sur la fiche de la saison 1, qui se voit
+   * reléguée à « Compat ». Les deux repères sont VRAIS ligne par ligne et la
+   * phrase qu'ils forment est fausse, ce qui est précisément pourquoi aucun
+   * garde-fou ne peut vivre ici. C'est le composant qui envoie une portée
+   * (`scope=season&season=1`) et qui refuse de calculer quand la portée `all`
+   * mélange les découpes d'une série (`bounded`).
+   */
+  it('compare deux saisons sans broncher si on la laisse faire', () => {
+    const markers = assignVersionMarkers([
+      facts('Cats.Eye.S01.MULTi.1080p.BluRay.x264-KAZETV', 56306370355),
+      facts('Cats.Eye.S02.MULTi.2160p.BluRay.x265-KAZETV', 57872165399),
+    ]);
+    expect(markers).toEqual(['compat', 'imageMax']);
+  });
+
+  /*
+   * Les deux saisons RÉELLES du catalogue, elles, ne reçoivent rien — non pas
+   * parce que la borne aurait servi, mais parce qu'elles sont identiques sur
+   * les trois axes de l'image et que 52,4 contre 53,9 Gio n'est pas un écart.
+   * Un rendu propre pour la mauvaise raison : mesuré, pour qu'on ne le prenne
+   * pas pour une preuve que mélanger les unités est sans conséquence.
+   */
+  it('ne pose rien sur les deux saisons du catalogue, par égalité', () => {
+    const markers = assignVersionMarkers([
+      facts('Cats.Eye.S02.MULTi.1080p.BluRay.x264-KAZETV', 57872165399),
+      facts('Cats.Eye.S01.MULTi.1080p.BluRay.x264-KAZETV', 56306370355),
+    ]);
+    expect(markers).toEqual([null, null]);
+  });
+});
diff --git a/doc/guide/hit-and-run.md b/doc/guide/hit-and-run.md
index f562ac61..554a26ac 100644
--- a/doc/guide/hit-and-run.md
+++ b/doc/guide/hit-and-run.md
@@ -8,8 +8,8 @@ A *hit-and-run* is a user who downloads a torrent and stops seeding before the o
 
 | Term                | Meaning                                                                                            |
 | ------------------- | -------------------------------------------------------------------------------------------------- |
-| **Required seed time** | How long (seconds) a user must seed a given torrent before HnR is cleared. Default `86400` (24 h). Operator-configurable from `/admin/settings`. |
-| **Grace period**    | Window after `downloadedAt` during which a not-yet-completed download is *not* flagged. Configurable in `/admin/settings`. |
+| **Required seed time** | How long a user must seed a given torrent before HnR is cleared. Default 24 h. Set in hours from `/admin/settings` → *Hit & Run* (stored in seconds as `hnr_required_seed_time`). The torrent page announces it before the download ("commits you to N h of seeding"). |
+| **Grace period**    | Window after `downloadedAt` during which a not-yet-completed download is *not* flagged. Default 72 h, set in hours from `/admin/settings` → *Hit & Run* (`hnr_grace_period`). Tracking itself is switched on there too (`hnr_enabled`, off by default). |
 | **Completed**       | A row reached `seedTime >= requiredSeedTime`. `completedAt` is set; `isHnr` is forced to `false` and never re-flips. |
 | **Exempt**          | Moderator manually waives the requirement. Engine ignores the row from that point onward.         |
 | **Flagged (`isHnr = true`)** | The grace period expired, the user still hadn't met the requirement. Auto-clearable by completing or by moderator action. |
diff --git a/doc/guide/security.md b/doc/guide/security.md
index 6b2765d0..c9517179 100644
--- a/doc/guide/security.md
+++ b/doc/guide/security.md
@@ -23,6 +23,20 @@ Trackarr implements distributed rate limiting to prevent abuse:
 | Auth | 5/5min | IP blacklisted after violations |
 | Tracker | 200/min | Distributed sliding window |
 
+Every counter above is keyed on the **client** IP, which requires
+`TRUST_PROXY=true` behind a reverse proxy — see
+[Configuration](./configuration.md). The one exception is the web container's
+own server-side rendering when nothing sits in front of it: those calls carry
+no forwarded-client header and arrive from a private address, so they are
+excluded from the 100 req/10s abuse counter and from the temporary blacklist it
+feeds. Without that exclusion the whole site shares a single counter — measured
+at four API calls per page view, which means about twenty-five page views in
+ten seconds would blacklist the instance for everyone. Behind the shipped Caddy
+the server-side calls inherit the visitor's `X-Forwarded-For`, so they are
+counted on the visitor's own address and the exclusion does not apply. Nothing
+else is relaxed for them: user-agent filtering, path and parameter validation,
+IP bans, per-route limits and authentication all still apply.
+
 ## IP Privacy
 
 User IP addresses are **never stored in plaintext**. Instead:
diff --git a/packages/db/src/migrations/0073_torrent_stats_history.sql b/packages/db/src/migrations/0073_torrent_stats_history.sql
new file mode 100644
index 00000000..9185636c
--- /dev/null
+++ b/packages/db/src/migrations/0073_torrent_stats_history.sql
@@ -0,0 +1,21 @@
+-- L'historique des essaims, un point par torrent et par jour.
+--
+-- `torrent_stats` est un instantané : il dit combien de sources il y a
+-- maintenant, jamais s'il y en avait plus hier. La fiche d'un torrent veut la
+-- tendance — sept jours de sources en courbe — et c'est cette table qui la
+-- porte. Le collecteur y écrit à la fin de chaque passe complète et élague ce
+-- qui a plus de trente jours.
+--
+-- La clé primaire (info_hash, day) est aussi l'index qu'il faut : la fiche lit
+-- les sept dernières lignes d'UN torrent, l'élagage balaie par `day` — et un
+-- index séparé sur `day` seul n'a pas été jugé utile : l'élagage tourne une
+-- fois par heure sur une table qui ne grandit que de N lignes par jour.
+CREATE TABLE "torrent_stats_history" (
+	"info_hash" text NOT NULL,
+	"day" date NOT NULL,
+	"seeders" integer DEFAULT 0 NOT NULL,
+	"leechers" integer DEFAULT 0 NOT NULL,
+	CONSTRAINT "torrent_stats_history_info_hash_day_pk" PRIMARY KEY("info_hash","day")
+);
+--> statement-breakpoint
+ALTER TABLE "torrent_stats_history" ADD CONSTRAINT "torrent_stats_history_info_hash_torrents_info_hash_fk" FOREIGN KEY ("info_hash") REFERENCES "public"."torrents"("info_hash") ON DELETE cascade ON UPDATE no action;
diff --git a/packages/db/src/migrations/0074_saved_searches_seen_count.sql b/packages/db/src/migrations/0074_saved_searches_seen_count.sql
new file mode 100644
index 00000000..8ac9777a
--- /dev/null
+++ b/packages/db/src/migrations/0074_saved_searches_seen_count.sql
@@ -0,0 +1,11 @@
+-- Le compteur de correspondances déjà vues.
+--
+-- `match_count` dit combien de releases ont déclenché une recherche
+-- enregistrée depuis sa création, jamais combien le membre en a vu. Le bandeau
+-- d'alertes du catalogue veut « 2 nouv. » : c'est la différence entre les deux,
+-- et `seen_count` rejoint `match_count` quand l'alerte est ouverte depuis là.
+-- Un compteur plutôt qu'une date : `match_count` ne recule jamais.
+--
+-- Généré par drizzle-kit puis réduit à la main : le dernier instantané datait
+-- de 0070, le diff recréait la table de 0073 qui existe déjà partout.
+ALTER TABLE "saved_searches" ADD COLUMN "seen_count" integer DEFAULT 0 NOT NULL;
diff --git a/packages/db/src/migrations/0075_fts_split_dotted_names.sql b/packages/db/src/migrations/0075_fts_split_dotted_names.sql
new file mode 100644
index 00000000..bfcf1866
--- /dev/null
+++ b/packages/db/src/migrations/0075_fts_split_dotted_names.sql
@@ -0,0 +1,19 @@
+-- La recherche plein texte découpe désormais les noms pointés.
+--
+-- `Sousou.no.Frieren.S01E09.VOSTFR.1080p.WEBRip` est UN jeton pour l'analyseur
+-- de Postgres (une forme d'hôte ou de fichier) : « frieren » ne trouvait qu'une
+-- release sur neuf, et le repli approximatif masquait le trou tant que la
+-- recherche exacte rendait zéro. Le vecteur indexé remplace points et
+-- soulignés par des espaces avant `to_tsvector` (voir `packages/db/src/search.ts`,
+-- même expression côté requête, sinon l'index ne servirait plus).
+--
+-- Quatre index recréés : le temps d'un CREATE INDEX par table — sur un gros
+-- catalogue, quelques secondes pendant lesquelles les écritures attendent.
+DROP INDEX "tags_fts_name_idx";--> statement-breakpoint
+DROP INDEX "torrents_fts_name_idx";--> statement-breakpoint
+DROP INDEX "torrents_fts_description_idx";--> statement-breakpoint
+DROP INDEX "torrents_fts_nfo_idx";--> statement-breakpoint
+CREATE INDEX "tags_fts_name_idx" ON "tags" USING gin (to_tsvector('simple', coalesce(translate("name", '._', '  '), '')));--> statement-breakpoint
+CREATE INDEX "torrents_fts_name_idx" ON "torrents" USING gin (to_tsvector('simple', coalesce(translate("name", '._', '  '), '')));--> statement-breakpoint
+CREATE INDEX "torrents_fts_description_idx" ON "torrents" USING gin (to_tsvector('simple', coalesce(translate("description", '._', '  '), '')));--> statement-breakpoint
+CREATE INDEX "torrents_fts_nfo_idx" ON "torrents" USING gin (to_tsvector('simple', coalesce(translate("nfo", '._', '  '), '')));
\ No newline at end of file
diff --git a/packages/db/src/migrations/0076_catalogue_alerts_titles_misses.sql b/packages/db/src/migrations/0076_catalogue_alerts_titles_misses.sql
new file mode 100644
index 00000000..4cebc830
--- /dev/null
+++ b/packages/db/src/migrations/0076_catalogue_alerts_titles_misses.sql
@@ -0,0 +1,39 @@
+-- Le catalogue, suite : des alertes fidèles, des titres d'œuvres, ce qu'on cherche en vain.
+--
+-- `saved_searches` reçoit les critères de la barre (groupes d'étiquettes, saison,
+-- épisode, année, uploadeur) : enregistrée, une recherche se reproduit telle
+-- qu'on l'avait sous les yeux. `users.catalogue_defaults` garde les filtres
+-- qu'un membre veut retrouver à chaque ouverture. `work_titles` indexe les titres
+-- que les fournisseurs de métadonnées donnent, pour que la recherche trouve une
+-- œuvre par son nom et propose « vouliez-vous dire ». `search_misses` compte
+-- les recherches à zéro résultat, pour l'administration.
+CREATE TABLE "search_misses" (
+	"query" text PRIMARY KEY NOT NULL,
+	"count" integer DEFAULT 1 NOT NULL,
+	"first_at" timestamp DEFAULT now() NOT NULL,
+	"last_at" timestamp DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "work_titles" (
+	"source" text NOT NULL,
+	"external_id" text NOT NULL,
+	"bare_id" text NOT NULL,
+	"locale" text NOT NULL,
+	"title" text NOT NULL,
+	"original_title" text,
+	"year" smallint,
+	"updated_at" timestamp DEFAULT now() NOT NULL,
+	CONSTRAINT "work_titles_source_external_id_locale_pk" PRIMARY KEY("source","external_id","locale")
+);
+--> statement-breakpoint
+ALTER TABLE "saved_searches" ADD COLUMN "tag_groups" text;--> statement-breakpoint
+ALTER TABLE "saved_searches" ADD COLUMN "season" smallint;--> statement-breakpoint
+ALTER TABLE "saved_searches" ADD COLUMN "episode" smallint;--> statement-breakpoint
+ALTER TABLE "saved_searches" ADD COLUMN "year" smallint;--> statement-breakpoint
+ALTER TABLE "saved_searches" ADD COLUMN "uploader_id" text;--> statement-breakpoint
+ALTER TABLE "users" ADD COLUMN "catalogue_defaults" jsonb;--> statement-breakpoint
+CREATE INDEX "search_misses_count_idx" ON "search_misses" USING btree ("count" DESC NULLS LAST,"last_at" DESC NULLS LAST);--> statement-breakpoint
+CREATE INDEX "work_titles_bare_idx" ON "work_titles" USING btree ("source","bare_id");--> statement-breakpoint
+CREATE INDEX "work_titles_fts_idx" ON "work_titles" USING gin (to_tsvector('simple', coalesce(translate("title", '._', '  '), '')));--> statement-breakpoint
+CREATE INDEX "work_titles_trgm_idx" ON "work_titles" USING gin ("title" gin_trgm_ops);--> statement-breakpoint
+ALTER TABLE "saved_searches" ADD CONSTRAINT "saved_searches_uploader_id_users_id_fk" FOREIGN KEY ("uploader_id") REFERENCES "public"."users"("id") ON DELETE set null ON UPDATE no action;
\ No newline at end of file
diff --git a/packages/db/src/migrations/meta/0074_snapshot.json b/packages/db/src/migrations/meta/0074_snapshot.json
new file mode 100644
index 00000000..60f5e4b7
--- /dev/null
+++ b/packages/db/src/migrations/meta/0074_snapshot.json
@@ -0,0 +1,10595 @@
+{
+  "id": "9f821a03-8c53-4b8b-ab1c-0b617b6a0b6b",
+  "prevId": "c29e2aa3-4971-4d58-bd28-b1c44fa3b8f8",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.announce_log": {
+      "name": "announce_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "event": {
+          "name": "event",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ip_hash": {
+          "name": "ip_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "port": {
+          "name": "port",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "uploaded": {
+          "name": "uploaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "downloaded": {
+          "name": "downloaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "left": {
+          "name": "left",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "announce_log_info_hash_idx": {
+          "name": "announce_log_info_hash_idx",
+          "columns": [
+            {
+              "expression": "info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "announce_log_created_at_idx": {
+          "name": "announce_log_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.anticheat_flags": {
+      "name": "anticheat_flags",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "severity": {
+          "name": "severity",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'medium'"
+        },
+        "details": {
+          "name": "details",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ip": {
+          "name": "ip",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "reviewed_at": {
+          "name": "reviewed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reviewed_by_id": {
+          "name": "reviewed_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "review_verdict": {
+          "name": "review_verdict",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "review_note": {
+          "name": "review_note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "anticheat_flags_torrent_idx": {
+          "name": "anticheat_flags_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "anticheat_flags_user_idx": {
+          "name": "anticheat_flags_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "anticheat_flags_unreviewed_idx": {
+          "name": "anticheat_flags_unreviewed_idx",
+          "columns": [
+            {
+              "expression": "reviewed_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "anticheat_flags_kind_idx": {
+          "name": "anticheat_flags_kind_idx",
+          "columns": [
+            {
+              "expression": "kind",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "anticheat_flags_no_leecher_open_unique": {
+          "name": "anticheat_flags_no_leecher_open_unique",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "kind = 'no_leecher' AND reviewed_at IS NULL AND torrent_id IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "anticheat_flags_user_id_users_id_fk": {
+          "name": "anticheat_flags_user_id_users_id_fk",
+          "tableFrom": "anticheat_flags",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "anticheat_flags_torrent_id_torrents_id_fk": {
+          "name": "anticheat_flags_torrent_id_torrents_id_fk",
+          "tableFrom": "anticheat_flags",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "anticheat_flags_reviewed_by_id_users_id_fk": {
+          "name": "anticheat_flags_reviewed_by_id_users_id_fk",
+          "tableFrom": "anticheat_flags",
+          "tableTo": "users",
+          "columnsFrom": [
+            "reviewed_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.audit_log": {
+      "name": "audit_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "actor_name": {
+          "name": "actor_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_role": {
+          "name": "actor_role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "method": {
+          "name": "method",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_type": {
+          "name": "target_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_label": {
+          "name": "target_label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "changes": {
+          "name": "changes",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status_code": {
+          "name": "status_code",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_ip_hash": {
+          "name": "actor_ip_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "audit_log_created_idx": {
+          "name": "audit_log_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "audit_log_actor_idx": {
+          "name": "audit_log_actor_idx",
+          "columns": [
+            {
+              "expression": "actor_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "audit_log_target_idx": {
+          "name": "audit_log_target_idx",
+          "columns": [
+            {
+              "expression": "target_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "target_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "audit_log_action_idx": {
+          "name": "audit_log_action_idx",
+          "columns": [
+            {
+              "expression": "action",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "audit_log_actor_id_users_id_fk": {
+          "name": "audit_log_actor_id_users_id_fk",
+          "tableFrom": "audit_log",
+          "tableTo": "users",
+          "columnsFrom": [
+            "actor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.banned_ips": {
+      "name": "banned_ips",
+      "schema": "",
+      "columns": {
+        "ip": {
+          "name": "ip",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_age_tiers": {
+      "name": "bonus_age_tiers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "min_age_days": {
+          "name": "min_age_days",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "multiplier": {
+          "name": "multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "bonus_age_tiers_threshold_idx": {
+          "name": "bonus_age_tiers_threshold_idx",
+          "columns": [
+            {
+              "expression": "min_age_days",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_age_tiers_enabled_idx": {
+          "name": "bonus_age_tiers_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_events": {
+      "name": "bonus_events",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "long_description": {
+          "name": "long_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "download_multiplier": {
+          "name": "download_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "upload_multiplier": {
+          "name": "upload_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "starts_at": {
+          "name": "starts_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ends_at": {
+          "name": "ends_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'manual'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "created_by_id": {
+          "name": "created_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "bonus_events_window_idx": {
+          "name": "bonus_events_window_idx",
+          "columns": [
+            {
+              "expression": "starts_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "ends_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_events_enabled_idx": {
+          "name": "bonus_events_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "bonus_events_created_by_id_users_id_fk": {
+          "name": "bonus_events_created_by_id_users_id_fk",
+          "tableFrom": "bonus_events",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_grants": {
+      "name": "bonus_grants",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "amount": {
+          "name": "amount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "bonus_grants_user_idx": {
+          "name": "bonus_grants_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_grants_source_user_torrent_idx": {
+          "name": "bonus_grants_source_user_torrent_idx",
+          "columns": [
+            {
+              "expression": "source",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_grants_first_seeder_unique_idx": {
+          "name": "bonus_grants_first_seeder_unique_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "source = 'first_seeder' AND torrent_id IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "bonus_grants_user_id_users_id_fk": {
+          "name": "bonus_grants_user_id_users_id_fk",
+          "tableFrom": "bonus_grants",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "bonus_grants_torrent_id_torrents_id_fk": {
+          "name": "bonus_grants_torrent_id_torrents_id_fk",
+          "tableFrom": "bonus_grants",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_rules": {
+      "name": "bonus_rules",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "config": {
+          "name": "config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "bonus_rules_kind_idx": {
+          "name": "bonus_rules_kind_idx",
+          "columns": [
+            {
+              "expression": "kind",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "bonus_rules_kind_unique": {
+          "name": "bonus_rules_kind_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "kind"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_seed_count_tiers": {
+      "name": "bonus_seed_count_tiers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "max_seeders": {
+          "name": "max_seeders",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "multiplier": {
+          "name": "multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "bonus_seed_count_tiers_threshold_idx": {
+          "name": "bonus_seed_count_tiers_threshold_idx",
+          "columns": [
+            {
+              "expression": "max_seeders",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_seed_count_tiers_enabled_idx": {
+          "name": "bonus_seed_count_tiers_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.catalog_records": {
+      "name": "catalog_records",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'torrent'"
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'local'"
+        },
+        "hops": {
+          "name": "hops",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "via": {
+          "name": "via",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content_hash": {
+          "name": "content_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "supersedes": {
+          "name": "supersedes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "superseded_at": {
+          "name": "superseded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "catalog_records_info_hash_idx": {
+          "name": "catalog_records_info_hash_idx",
+          "columns": [
+            {
+              "expression": "info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "catalog_records_created_idx": {
+          "name": "catalog_records_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "catalog_records_relayable_idx": {
+          "name": "catalog_records_relayable_idx",
+          "columns": [
+            {
+              "expression": "origin",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "hops",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "catalog_records_live_idx": {
+          "name": "catalog_records_live_idx",
+          "columns": [
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "superseded_at IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "catalog_records_current_idx": {
+          "name": "catalog_records_current_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "superseded_at IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "catalog_records_origin_ck": {
+          "name": "catalog_records_origin_ck",
+          "value": "\"catalog_records\".\"origin\" IN ('local', 'ingested')"
+        },
+        "catalog_records_kind_ck": {
+          "name": "catalog_records_kind_ck",
+          "value": "\"catalog_records\".\"kind\" IN ('torrent', 'tombstone', 'identity', 'revocation')"
+        },
+        "catalog_records_hops_ck": {
+          "name": "catalog_records_hops_ck",
+          "value": "\"catalog_records\".\"hops\" BETWEEN 0 AND 2"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.categories": {
+      "name": "categories",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parent_id": {
+          "name": "parent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "newznab_id": {
+          "name": "newznab_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_adult": {
+          "name": "is_adult",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "categories_parent_idx": {
+          "name": "categories_parent_idx",
+          "columns": [
+            {
+              "expression": "parent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "categories_slug_unique": {
+          "name": "categories_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.conversation_participants": {
+      "name": "conversation_participants",
+      "schema": "",
+      "columns": {
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "joined_at": {
+          "name": "joined_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_read_at": {
+          "name": "last_read_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "unread_count": {
+          "name": "unread_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "muted_until": {
+          "name": "muted_until",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "archived_at": {
+          "name": "archived_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "state": {
+          "name": "state",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'active'"
+        }
+      },
+      "indexes": {
+        "conversation_participants_inbox_idx": {
+          "name": "conversation_participants_inbox_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "state",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "archived_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "conversation_participants_conversation_id_conversations_id_fk": {
+          "name": "conversation_participants_conversation_id_conversations_id_fk",
+          "tableFrom": "conversation_participants",
+          "tableTo": "conversations",
+          "columnsFrom": [
+            "conversation_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "conversation_participants_user_id_users_id_fk": {
+          "name": "conversation_participants_user_id_users_id_fk",
+          "tableFrom": "conversation_participants",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "conversation_participants_conversation_id_user_id_pk": {
+          "name": "conversation_participants_conversation_id_user_id_pk",
+          "columns": [
+            "conversation_id",
+            "user_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "conversation_participants_state_ck": {
+          "name": "conversation_participants_state_ck",
+          "value": "\"conversation_participants\".\"state\" IN ('active', 'pending', 'blocked')"
+        },
+        "conversation_participants_unread_ck": {
+          "name": "conversation_participants_unread_ck",
+          "value": "\"conversation_participants\".\"unread_count\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.conversations": {
+      "name": "conversations",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "pinned_message_id": {
+          "name": "pinned_message_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pinned_at": {
+          "name": "pinned_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pinned_by_id": {
+          "name": "pinned_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "encrypted": {
+          "name": "encrypted",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_by_id": {
+          "name": "created_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_message_at": {
+          "name": "last_message_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "conversations_slug_idx": {
+          "name": "conversations_slug_idx",
+          "columns": [
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "conversations_last_message_idx": {
+          "name": "conversations_last_message_idx",
+          "columns": [
+            {
+              "expression": "last_message_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "conversations_created_by_id_users_id_fk": {
+          "name": "conversations_created_by_id_users_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "conversations_kind_ck": {
+          "name": "conversations_kind_ck",
+          "value": "\"conversations\".\"kind\" IN ('dm', 'room')"
+        },
+        "conversations_room_slug_ck": {
+          "name": "conversations_room_slug_ck",
+          "value": "(\"conversations\".\"kind\" = 'room') = (\"conversations\".\"slug\" IS NOT NULL)"
+        },
+        "conversations_room_plain_ck": {
+          "name": "conversations_room_plain_ck",
+          "value": "NOT (\"conversations\".\"kind\" = 'room' AND \"conversations\".\"encrypted\")"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.federated_follows": {
+      "name": "federated_follows",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "local_user_id": {
+          "name": "local_user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "remote_username": {
+          "name": "remote_username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "federated_follows_unique": {
+          "name": "federated_follows_unique",
+          "columns": [
+            {
+              "expression": "local_user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "remote_username",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "federated_follows_target_idx": {
+          "name": "federated_follows_target_idx",
+          "columns": [
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "remote_username",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "federated_follows_local_user_id_users_id_fk": {
+          "name": "federated_follows_local_user_id_users_id_fk",
+          "tableFrom": "federated_follows",
+          "tableTo": "users",
+          "columnsFrom": [
+            "local_user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "federated_follows_peer_id_federation_peers_id_fk": {
+          "name": "federated_follows_peer_id_federation_peers_id_fk",
+          "tableFrom": "federated_follows",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federated_identities": {
+      "name": "federated_identities",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "local_user_id": {
+          "name": "local_user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "remote_username": {
+          "name": "remote_username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "method": {
+          "name": "method",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'bio'"
+        },
+        "subject_did": {
+          "name": "subject_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "evidence": {
+          "name": "evidence",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "verify_code": {
+          "name": "verify_code",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "verified_at": {
+          "name": "verified_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "federated_identities_unique": {
+          "name": "federated_identities_unique",
+          "columns": [
+            {
+              "expression": "local_user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "remote_username",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "federated_identities_local_user_id_users_id_fk": {
+          "name": "federated_identities_local_user_id_users_id_fk",
+          "tableFrom": "federated_identities",
+          "tableTo": "users",
+          "columnsFrom": [
+            "local_user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "federated_identities_peer_id_federation_peers_id_fk": {
+          "name": "federated_identities_peer_id_federation_peers_id_fk",
+          "tableFrom": "federated_identities",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federation_config": {
+      "name": "federation_config",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "'singleton'"
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "relay_enabled": {
+          "name": "relay_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "discoverable": {
+          "name": "discoverable",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "instance_name": {
+          "name": "instance_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "public_url": {
+          "name": "public_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "instance_id": {
+          "name": "instance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "private_key_enc": {
+          "name": "private_key_enc",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "default_scopes": {
+          "name": "default_scopes",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"catalog\":false,\"social\":false,\"accounts\":false,\"swarm\":false}'::jsonb"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federation_credit_grants": {
+      "name": "federation_credit_grants",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "subject_did": {
+          "name": "subject_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "local_user_id": {
+          "name": "local_user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bytes": {
+          "name": "bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "period_start": {
+          "name": "period_start",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "period_end": {
+          "name": "period_end",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "federation_credit_grants_user_idx": {
+          "name": "federation_credit_grants_user_idx",
+          "columns": [
+            {
+              "expression": "local_user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "federation_credit_grants_period_idx": {
+          "name": "federation_credit_grants_period_idx",
+          "columns": [
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "subject_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "period_end",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "federation_credit_grants_created_idx": {
+          "name": "federation_credit_grants_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "federation_credit_grants_peer_id_federation_peers_id_fk": {
+          "name": "federation_credit_grants_peer_id_federation_peers_id_fk",
+          "tableFrom": "federation_credit_grants",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "federation_credit_grants_local_user_id_users_id_fk": {
+          "name": "federation_credit_grants_local_user_id_users_id_fk",
+          "tableFrom": "federation_credit_grants",
+          "tableTo": "users",
+          "columnsFrom": [
+            "local_user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federation_peers": {
+      "name": "federation_peers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "base_url": {
+          "name": "base_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "instance_id": {
+          "name": "instance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending_out'"
+        },
+        "shares_with_them": {
+          "name": "shares_with_them",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"catalog\":false,\"social\":false,\"accounts\":false,\"swarm\":false}'::jsonb"
+        },
+        "accepts_from_them": {
+          "name": "accepts_from_them",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"catalog\":false,\"social\":false,\"accounts\":false,\"swarm\":false}'::jsonb"
+        },
+        "last_handshake_at": {
+          "name": "last_handshake_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_seen_at": {
+          "name": "last_seen_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "protocol_version": {
+          "name": "protocol_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "federation_peers_status_idx": {
+          "name": "federation_peers_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "federation_peers_instance_id_unique": {
+          "name": "federation_peers_instance_id_unique",
+          "columns": [
+            {
+              "expression": "instance_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "instance_id IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "federation_peers_created_by_users_id_fk": {
+          "name": "federation_peers_created_by_users_id_fk",
+          "tableFrom": "federation_peers",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "federation_peers_base_url_unique": {
+          "name": "federation_peers_base_url_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "base_url"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federation_sync_state": {
+      "name": "federation_sync_state",
+      "schema": "",
+      "columns": {
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "resource": {
+          "name": "resource",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cursor": {
+          "name": "cursor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_run_at": {
+          "name": "last_run_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_status": {
+          "name": "last_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "items_synced": {
+          "name": "items_synced",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "federation_sync_state_peer_id_federation_peers_id_fk": {
+          "name": "federation_sync_state_peer_id_federation_peers_id_fk",
+          "tableFrom": "federation_sync_state",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "federation_sync_state_peer_id_resource_pk": {
+          "name": "federation_sync_state_peer_id_resource_pk",
+          "columns": [
+            "peer_id",
+            "resource"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.forum_categories": {
+      "name": "forum_categories",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "color": {
+          "name": "color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "order": {
+          "name": "order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.forum_posts": {
+      "name": "forum_posts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "topic_id": {
+          "name": "topic_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "forum_posts_topic_idx": {
+          "name": "forum_posts_topic_idx",
+          "columns": [
+            {
+              "expression": "topic_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "forum_posts_author_idx": {
+          "name": "forum_posts_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "forum_posts_topic_id_forum_topics_id_fk": {
+          "name": "forum_posts_topic_id_forum_topics_id_fk",
+          "tableFrom": "forum_posts",
+          "tableTo": "forum_topics",
+          "columnsFrom": [
+            "topic_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "forum_posts_author_id_users_id_fk": {
+          "name": "forum_posts_author_id_users_id_fk",
+          "tableFrom": "forum_posts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.forum_topics": {
+      "name": "forum_topics",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_pinned": {
+          "name": "is_pinned",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_locked": {
+          "name": "is_locked",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "forum_topics_category_idx": {
+          "name": "forum_topics_category_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "forum_topics_author_idx": {
+          "name": "forum_topics_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "forum_topics_category_id_forum_categories_id_fk": {
+          "name": "forum_topics_category_id_forum_categories_id_fk",
+          "tableFrom": "forum_topics",
+          "tableTo": "forum_categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "forum_topics_author_id_users_id_fk": {
+          "name": "forum_topics_author_id_users_id_fk",
+          "tableFrom": "forum_topics",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.freeleech_pool_config": {
+      "name": "freeleech_pool_config",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "points_target": {
+          "name": "points_target",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "freeleech_duration_days": {
+          "name": "freeleech_duration_days",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "contribution_min": {
+          "name": "contribution_min",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "max_per_user_bp": {
+          "name": "max_per_user_bp",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "preset_amounts": {
+          "name": "preset_amounts",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "event_title_template": {
+          "name": "event_title_template",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event_description_template": {
+          "name": "event_description_template",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event_long_description_template": {
+          "name": "event_long_description_template",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "freeleech_pool_config_singleton": {
+          "name": "freeleech_pool_config_singleton",
+          "columns": [
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "id = 1",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.freeleech_pool_contributions": {
+      "name": "freeleech_pool_contributions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "cycle_id": {
+          "name": "cycle_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "amount": {
+          "name": "amount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "freeleech_pool_contributions_user_idx": {
+          "name": "freeleech_pool_contributions_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "freeleech_pool_contributions_cycle_idx": {
+          "name": "freeleech_pool_contributions_cycle_idx",
+          "columns": [
+            {
+              "expression": "cycle_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "freeleech_pool_contributions_cycle_user_idx": {
+          "name": "freeleech_pool_contributions_cycle_user_idx",
+          "columns": [
+            {
+              "expression": "cycle_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "freeleech_pool_contributions_cycle_id_freeleech_pool_cycles_id_fk": {
+          "name": "freeleech_pool_contributions_cycle_id_freeleech_pool_cycles_id_fk",
+          "tableFrom": "freeleech_pool_contributions",
+          "tableTo": "freeleech_pool_cycles",
+          "columnsFrom": [
+            "cycle_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "freeleech_pool_contributions_user_id_users_id_fk": {
+          "name": "freeleech_pool_contributions_user_id_users_id_fk",
+          "tableFrom": "freeleech_pool_contributions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.freeleech_pool_cycles": {
+      "name": "freeleech_pool_cycles",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'filling'"
+        },
+        "target_snapshot": {
+          "name": "target_snapshot",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "duration_days_snapshot": {
+          "name": "duration_days_snapshot",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total_contributed": {
+          "name": "total_contributed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ends_at": {
+          "name": "ends_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "triggered_event_id": {
+          "name": "triggered_event_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_title": {
+          "name": "paused_event_title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_description": {
+          "name": "paused_event_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_long_description": {
+          "name": "paused_event_long_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_download_multiplier": {
+          "name": "paused_event_download_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_upload_multiplier": {
+          "name": "paused_event_upload_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_remaining_ms": {
+          "name": "paused_event_remaining_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_created_by_id": {
+          "name": "paused_event_created_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "waiting_on_event_id": {
+          "name": "waiting_on_event_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "closed_at": {
+          "name": "closed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "freeleech_pool_cycles_status_idx": {
+          "name": "freeleech_pool_cycles_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "freeleech_pool_cycles_open_unique": {
+          "name": "freeleech_pool_cycles_open_unique",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "status IN ('filling', 'full_queued', 'active')",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "freeleech_pool_cycles_triggered_event_id_bonus_events_id_fk": {
+          "name": "freeleech_pool_cycles_triggered_event_id_bonus_events_id_fk",
+          "tableFrom": "freeleech_pool_cycles",
+          "tableTo": "bonus_events",
+          "columnsFrom": [
+            "triggered_event_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "freeleech_pool_cycles_paused_event_created_by_id_users_id_fk": {
+          "name": "freeleech_pool_cycles_paused_event_created_by_id_users_id_fk",
+          "tableFrom": "freeleech_pool_cycles",
+          "tableTo": "users",
+          "columnsFrom": [
+            "paused_event_created_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "freeleech_pool_cycles_waiting_on_event_id_bonus_events_id_fk": {
+          "name": "freeleech_pool_cycles_waiting_on_event_id_bonus_events_id_fk",
+          "tableFrom": "freeleech_pool_cycles",
+          "tableTo": "bonus_events",
+          "columnsFrom": [
+            "waiting_on_event_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.freeleech_pool_windows": {
+      "name": "freeleech_pool_windows",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "starts_at": {
+          "name": "starts_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ends_at": {
+          "name": "ends_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "weekday_start": {
+          "name": "weekday_start",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "weekday_end": {
+          "name": "weekday_end",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "minute_start": {
+          "name": "minute_start",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "minute_end": {
+          "name": "minute_end",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "monthly_days": {
+          "name": "monthly_days",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year_month_start": {
+          "name": "year_month_start",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year_day_start": {
+          "name": "year_day_start",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year_month_end": {
+          "name": "year_month_end",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year_day_end": {
+          "name": "year_day_end",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "label": {
+          "name": "label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "freeleech_pool_windows_kind_idx": {
+          "name": "freeleech_pool_windows_kind_idx",
+          "columns": [
+            {
+              "expression": "kind",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "freeleech_pool_windows_oneoff_idx": {
+          "name": "freeleech_pool_windows_oneoff_idx",
+          "columns": [
+            {
+              "expression": "starts_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "ends_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.hnr_tracking": {
+      "name": "hnr_tracking",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "downloaded_at": {
+          "name": "downloaded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "seed_time": {
+          "name": "seed_time",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "required_seed_time": {
+          "name": "required_seed_time",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 86400
+        },
+        "is_hnr": {
+          "name": "is_hnr",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_exempt": {
+          "name": "is_exempt",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "uploaded": {
+          "name": "uploaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "downloaded": {
+          "name": "downloaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "hnr_downloaded_at_idx": {
+          "name": "hnr_downloaded_at_idx",
+          "columns": [
+            {
+              "expression": "downloaded_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_completed_at_idx": {
+          "name": "hnr_completed_at_idx",
+          "columns": [
+            {
+              "expression": "completed_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_torrent_idx": {
+          "name": "hnr_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_status_idx": {
+          "name": "hnr_status_idx",
+          "columns": [
+            {
+              "expression": "is_hnr",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"hnr_tracking\".\"is_hnr\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_user_torrent_idx": {
+          "name": "hnr_user_torrent_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_user_is_hnr_idx": {
+          "name": "hnr_user_is_hnr_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "is_hnr",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "hnr_tracking_user_id_users_id_fk": {
+          "name": "hnr_tracking_user_id_users_id_fk",
+          "tableFrom": "hnr_tracking",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "hnr_tracking_torrent_id_torrents_id_fk": {
+          "name": "hnr_tracking_torrent_id_torrents_id_fk",
+          "tableFrom": "hnr_tracking",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.invitations": {
+      "name": "invitations",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "code": {
+          "name": "code",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "used_by": {
+          "name": "used_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "used_at": {
+          "name": "used_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "invitations_created_by_idx": {
+          "name": "invitations_created_by_idx",
+          "columns": [
+            {
+              "expression": "created_by",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "invitations_used_by_idx": {
+          "name": "invitations_used_by_idx",
+          "columns": [
+            {
+              "expression": "used_by",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"invitations\".\"used_by\" IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "invitations_created_by_users_id_fk": {
+          "name": "invitations_created_by_users_id_fk",
+          "tableFrom": "invitations",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "invitations_used_by_users_id_fk": {
+          "name": "invitations_used_by_users_id_fk",
+          "tableFrom": "invitations",
+          "tableTo": "users",
+          "columnsFrom": [
+            "used_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "invitations_code_unique": {
+          "name": "invitations_code_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "code"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.login_events": {
+      "name": "login_events",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "method": {
+          "name": "method",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "outcome": {
+          "name": "outcome",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_hash": {
+          "name": "ip_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "login_events_user_idx": {
+          "name": "login_events_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "login_events_created_idx": {
+          "name": "login_events_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "login_events_user_id_users_id_fk": {
+          "name": "login_events_user_id_users_id_fk",
+          "tableFrom": "login_events",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.message_reactions": {
+      "name": "message_reactions",
+      "schema": "",
+      "columns": {
+        "message_id": {
+          "name": "message_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "message_reactions_user_idx": {
+          "name": "message_reactions_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "message_reactions_message_id_messages_id_fk": {
+          "name": "message_reactions_message_id_messages_id_fk",
+          "tableFrom": "message_reactions",
+          "tableTo": "messages",
+          "columnsFrom": [
+            "message_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "message_reactions_user_id_users_id_fk": {
+          "name": "message_reactions_user_id_users_id_fk",
+          "tableFrom": "message_reactions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "message_reactions_message_id_user_id_key_pk": {
+          "name": "message_reactions_message_id_user_id_key_pk",
+          "columns": [
+            "message_id",
+            "user_id",
+            "key"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "message_reactions_key_ck": {
+          "name": "message_reactions_key_ck",
+          "value": "\"message_reactions\".\"key\" IN ('up', 'heart', 'haha', 'wow', 'thanks', 'done')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.message_read_log": {
+      "name": "message_read_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "reader_id": {
+          "name": "reader_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reader_name": {
+          "name": "reader_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "message_id": {
+          "name": "message_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "report_id": {
+          "name": "report_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "disclosed": {
+          "name": "disclosed",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "message_read_log_created_idx": {
+          "name": "message_read_log_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "message_read_log_reader_idx": {
+          "name": "message_read_log_reader_idx",
+          "columns": [
+            {
+              "expression": "reader_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "message_read_log_message_idx": {
+          "name": "message_read_log_message_idx",
+          "columns": [
+            {
+              "expression": "message_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "message_read_log_reader_id_users_id_fk": {
+          "name": "message_read_log_reader_id_users_id_fk",
+          "tableFrom": "message_read_log",
+          "tableTo": "users",
+          "columnsFrom": [
+            "reader_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.messages": {
+      "name": "messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reply_to_id": {
+          "name": "reply_to_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cipher": {
+          "name": "cipher",
+          "type": "bytea",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "iv": {
+          "name": "iv",
+          "type": "bytea",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_system": {
+          "name": "is_system",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "edited_at": {
+          "name": "edited_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_by_id": {
+          "name": "deleted_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "messages_reply_to_idx": {
+          "name": "messages_reply_to_idx",
+          "columns": [
+            {
+              "expression": "reply_to_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "messages_author_idx": {
+          "name": "messages_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "messages_conversation_idx": {
+          "name": "messages_conversation_idx",
+          "columns": [
+            {
+              "expression": "conversation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "messages_conversation_id_conversations_id_fk": {
+          "name": "messages_conversation_id_conversations_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "conversations",
+          "columnsFrom": [
+            "conversation_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "messages_author_id_users_id_fk": {
+          "name": "messages_author_id_users_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "messages_reply_to_id_messages_id_fk": {
+          "name": "messages_reply_to_id_messages_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "messages",
+          "columnsFrom": [
+            "reply_to_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "messages_deleted_by_id_users_id_fk": {
+          "name": "messages_deleted_by_id_users_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "deleted_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "messages_payload_ck": {
+          "name": "messages_payload_ck",
+          "value": "\"messages\".\"deleted_at\" IS NOT NULL OR ((\"messages\".\"body\" IS NOT NULL) <> (\"messages\".\"cipher\" IS NOT NULL))"
+        },
+        "messages_cipher_iv_ck": {
+          "name": "messages_cipher_iv_ck",
+          "value": "(\"messages\".\"cipher\" IS NULL) = (\"messages\".\"iv\" IS NULL)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.messaging_blocks": {
+      "name": "messaging_blocks",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "blocked_id": {
+          "name": "blocked_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "messaging_blocks_blocked_idx": {
+          "name": "messaging_blocks_blocked_idx",
+          "columns": [
+            {
+              "expression": "blocked_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "messaging_blocks_user_id_users_id_fk": {
+          "name": "messaging_blocks_user_id_users_id_fk",
+          "tableFrom": "messaging_blocks",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "messaging_blocks_blocked_id_users_id_fk": {
+          "name": "messaging_blocks_blocked_id_users_id_fk",
+          "tableFrom": "messaging_blocks",
+          "tableTo": "users",
+          "columnsFrom": [
+            "blocked_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "messaging_blocks_user_id_blocked_id_pk": {
+          "name": "messaging_blocks_user_id_blocked_id_pk",
+          "columns": [
+            "user_id",
+            "blocked_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "messaging_blocks_self_ck": {
+          "name": "messaging_blocks_self_ck",
+          "value": "\"messaging_blocks\".\"user_id\" <> \"messaging_blocks\".\"blocked_id\""
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.messaging_broadcasts": {
+      "name": "messaging_broadcasts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "created_by_id": {
+          "name": "created_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "audience": {
+          "name": "audience",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total": {
+          "name": "total",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "sent": {
+          "name": "sent",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "finished_at": {
+          "name": "finished_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error": {
+          "name": "error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "messaging_broadcasts_created_idx": {
+          "name": "messaging_broadcasts_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "messaging_broadcasts_created_by_id_users_id_fk": {
+          "name": "messaging_broadcasts_created_by_id_users_id_fk",
+          "tableFrom": "messaging_broadcasts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notification_channels": {
+      "name": "notification_channels",
+      "schema": "",
+      "columns": {
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "server_config": {
+          "name": "server_config",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "last_test_status": {
+          "name": "last_test_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_test_error": {
+          "name": "last_test_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_tested_at": {
+          "name": "last_tested_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_by": {
+          "name": "updated_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "notification_channels_updated_by_users_id_fk": {
+          "name": "notification_channels_updated_by_users_id_fk",
+          "tableFrom": "notification_channels",
+          "tableTo": "users",
+          "columnsFrom": [
+            "updated_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notifications": {
+      "name": "notifications",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "payload": {
+          "name": "payload",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "link": {
+          "name": "link",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "read_at": {
+          "name": "read_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "notifications_user_created_idx": {
+          "name": "notifications_user_created_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "notifications_user_unread_idx": {
+          "name": "notifications_user_unread_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "read_at IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "notifications_user_id_users_id_fk": {
+          "name": "notifications_user_id_users_id_fk",
+          "tableFrom": "notifications",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.panic_state": {
+      "name": "panic_state",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "'singleton'"
+        },
+        "is_encrypted": {
+          "name": "is_encrypted",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "encrypted_at": {
+          "name": "encrypted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "encryption_salt": {
+          "name": "encryption_salt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "encryption_iv": {
+          "name": "encryption_iv",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "kdf_version": {
+          "name": "kdf_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "panic_password_hash": {
+          "name": "panic_password_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "phase": {
+          "name": "phase",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'idle'"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "panic_state_phase_ck": {
+          "name": "panic_state_phase_ck",
+          "value": "\"panic_state\".\"phase\" IN ('idle', 'encrypting', 'encrypted', 'restoring')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.presentation_templates": {
+      "name": "presentation_templates",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'universal'"
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "visibility": {
+          "name": "visibility",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'private'"
+        },
+        "is_default": {
+          "name": "is_default",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "presentation_templates_owner_idx": {
+          "name": "presentation_templates_owner_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "presentation_templates_site_idx": {
+          "name": "presentation_templates_site_idx",
+          "columns": [
+            {
+              "expression": "category",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"presentation_templates\".\"visibility\" = 'site'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "presentation_templates_default_unique": {
+          "name": "presentation_templates_default_unique",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"presentation_templates\".\"is_default\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "presentation_templates_owner_id_users_id_fk": {
+          "name": "presentation_templates_owner_id_users_id_fk",
+          "tableFrom": "presentation_templates",
+          "tableTo": "users",
+          "columnsFrom": [
+            "owner_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "presentation_templates_created_by_users_id_fk": {
+          "name": "presentation_templates_created_by_users_id_fk",
+          "tableFrom": "presentation_templates",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "presentation_templates_scope_ck": {
+          "name": "presentation_templates_scope_ck",
+          "value": "(\"presentation_templates\".\"visibility\" = 'private' AND \"presentation_templates\".\"owner_id\" IS NOT NULL)\n          OR (\"presentation_templates\".\"visibility\" = 'site' AND \"presentation_templates\".\"owner_id\" IS NULL AND \"presentation_templates\".\"is_default\" = false)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.record_sources": {
+      "name": "record_sources",
+      "schema": "",
+      "columns": {
+        "record_id": {
+          "name": "record_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'torrent'"
+        },
+        "first_seen_at": {
+          "name": "first_seen_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "record_sources_record_idx": {
+          "name": "record_sources_record_idx",
+          "columns": [
+            {
+              "expression": "record_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "record_sources_peer_id_federation_peers_id_fk": {
+          "name": "record_sources_peer_id_federation_peers_id_fk",
+          "tableFrom": "record_sources",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "record_sources_peer_id_record_id_pk": {
+          "name": "record_sources_peer_id_record_id_pk",
+          "columns": [
+            "peer_id",
+            "record_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.recovery_codes": {
+      "name": "recovery_codes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "code_hash": {
+          "name": "code_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "used_at": {
+          "name": "used_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "recovery_codes_user_idx": {
+          "name": "recovery_codes_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "recovery_codes_user_id_users_id_fk": {
+          "name": "recovery_codes_user_id_users_id_fk",
+          "tableFrom": "recovery_codes",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.remote_category_map": {
+      "name": "remote_category_map",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "remote_slug": {
+          "name": "remote_slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "local_category_id": {
+          "name": "local_category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "remote_category_map_slug_idx": {
+          "name": "remote_category_map_slug_idx",
+          "columns": [
+            {
+              "expression": "remote_slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_category_map_category_idx": {
+          "name": "remote_category_map_category_idx",
+          "columns": [
+            {
+              "expression": "local_category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "remote_category_map_local_category_id_categories_id_fk": {
+          "name": "remote_category_map_local_category_id_categories_id_fk",
+          "tableFrom": "remote_category_map",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "local_category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "remote_category_map_created_by_users_id_fk": {
+          "name": "remote_category_map_created_by_users_id_fk",
+          "tableFrom": "remote_category_map",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.remote_identity_links": {
+      "name": "remote_identity_links",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject_did": {
+          "name": "subject_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "alias_did": {
+          "name": "alias_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "evidence": {
+          "name": "evidence",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "record_id": {
+          "name": "record_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "remote_identity_links_unique": {
+          "name": "remote_identity_links_unique",
+          "columns": [
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "subject_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "alias_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_identity_links_subject_idx": {
+          "name": "remote_identity_links_subject_idx",
+          "columns": [
+            {
+              "expression": "subject_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_identity_links_alias_idx": {
+          "name": "remote_identity_links_alias_idx",
+          "columns": [
+            {
+              "expression": "alias_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "remote_identity_links_peer_id_federation_peers_id_fk": {
+          "name": "remote_identity_links_peer_id_federation_peers_id_fk",
+          "tableFrom": "remote_identity_links",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.remote_masks": {
+      "name": "remote_masks",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "remote_masks_scope_value_idx": {
+          "name": "remote_masks_scope_value_idx",
+          "columns": [
+            {
+              "expression": "scope",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "value",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_masks_value_idx": {
+          "name": "remote_masks_value_idx",
+          "columns": [
+            {
+              "expression": "value",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "remote_masks_created_by_users_id_fk": {
+          "name": "remote_masks_created_by_users_id_fk",
+          "tableFrom": "remote_masks",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.remote_torrents": {
+      "name": "remote_torrents",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "remote_id": {
+          "name": "remote_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content_signature": {
+          "name": "content_signature",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "info_hash_v2": {
+          "name": "info_hash_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content_root_v2": {
+          "name": "content_root_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size": {
+          "name": "size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category_slug": {
+          "name": "category_slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category_type": {
+          "name": "category_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_adult": {
+          "name": "is_adult",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "tags": {
+          "name": "tags",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "imdb_id": {
+          "name": "imdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tmdb_id": {
+          "name": "tmdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tvdb_id": {
+          "name": "tvdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "igdb_id": {
+          "name": "igdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "openlibrary_id": {
+          "name": "openlibrary_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "season": {
+          "name": "season",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "episode": {
+          "name": "episode",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "seeders": {
+          "name": "seeders",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "leechers": {
+          "name": "leechers",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "completed": {
+          "name": "completed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "record_id": {
+          "name": "record_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "author_did": {
+          "name": "author_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "verified": {
+          "name": "verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "uploader_name": {
+          "name": "uploader_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote_created_at": {
+          "name": "remote_created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote_detail_url": {
+          "name": "remote_detail_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote_download_url": {
+          "name": "remote_download_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "fetched_at": {
+          "name": "fetched_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "remote_torrents_peer_remote_unique": {
+          "name": "remote_torrents_peer_remote_unique",
+          "columns": [
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "remote_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_info_hash_idx": {
+          "name": "remote_torrents_info_hash_idx",
+          "columns": [
+            {
+              "expression": "info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_content_root_v2_idx": {
+          "name": "remote_torrents_content_root_v2_idx",
+          "columns": [
+            {
+              "expression": "content_root_v2",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_content_sig_idx": {
+          "name": "remote_torrents_content_sig_idx",
+          "columns": [
+            {
+              "expression": "content_signature",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_imdb_idx": {
+          "name": "remote_torrents_imdb_idx",
+          "columns": [
+            {
+              "expression": "imdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_tmdb_idx": {
+          "name": "remote_torrents_tmdb_idx",
+          "columns": [
+            {
+              "expression": "tmdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_igdb_idx": {
+          "name": "remote_torrents_igdb_idx",
+          "columns": [
+            {
+              "expression": "igdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_openlibrary_idx": {
+          "name": "remote_torrents_openlibrary_idx",
+          "columns": [
+            {
+              "expression": "openlibrary_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_record_idx": {
+          "name": "remote_torrents_record_idx",
+          "columns": [
+            {
+              "expression": "record_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_author_idx": {
+          "name": "remote_torrents_author_idx",
+          "columns": [
+            {
+              "expression": "author_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_name_idx": {
+          "name": "remote_torrents_name_idx",
+          "columns": [
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "remote_torrents_peer_id_federation_peers_id_fk": {
+          "name": "remote_torrents_peer_id_federation_peers_id_fk",
+          "tableFrom": "remote_torrents",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.reports": {
+      "name": "reports",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "reporter_id": {
+          "name": "reporter_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_type": {
+          "name": "target_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "details": {
+          "name": "details",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "withdrawn_at": {
+          "name": "withdrawn_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resolved_by": {
+          "name": "resolved_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resolved_at": {
+          "name": "resolved_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resolution": {
+          "name": "resolution",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "reports_reporter_idx": {
+          "name": "reports_reporter_idx",
+          "columns": [
+            {
+              "expression": "reporter_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reports_target_idx": {
+          "name": "reports_target_idx",
+          "columns": [
+            {
+              "expression": "target_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "target_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reports_status_idx": {
+          "name": "reports_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reports_reporter_id_users_id_fk": {
+          "name": "reports_reporter_id_users_id_fk",
+          "tableFrom": "reports",
+          "tableTo": "users",
+          "columnsFrom": [
+            "reporter_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reports_resolved_by_users_id_fk": {
+          "name": "reports_resolved_by_users_id_fk",
+          "tableFrom": "reports",
+          "tableTo": "users",
+          "columnsFrom": [
+            "resolved_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.revoked_identities": {
+      "name": "revoked_identities",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "did": {
+          "name": "did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "succeeded_by": {
+          "name": "succeeded_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "record_id": {
+          "name": "record_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "revoked_at": {
+          "name": "revoked_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "revoked_identities_unique": {
+          "name": "revoked_identities_unique",
+          "columns": [
+            {
+              "expression": "issuer",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "revoked_identities_did_idx": {
+          "name": "revoked_identities_did_idx",
+          "columns": [
+            {
+              "expression": "did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.roles": {
+      "name": "roles",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "color": {
+          "name": "color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'#6b7280'"
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "show_as_badge": {
+          "name": "show_as_badge",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "priority": {
+          "name": "priority",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "assignment_mode": {
+          "name": "assignment_mode",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'manual'"
+        },
+        "rules": {
+          "name": "rules",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "can_upload_without_moderation": {
+          "name": "can_upload_without_moderation",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "roles_name_unique": {
+          "name": "roles_name_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "name"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.room_message_reactions": {
+      "name": "room_message_reactions",
+      "schema": "",
+      "columns": {
+        "message_id": {
+          "name": "message_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "message_created_at": {
+          "name": "message_created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "room_message_reactions_user_idx": {
+          "name": "room_message_reactions_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "room_message_reactions_message_idx": {
+          "name": "room_message_reactions_message_idx",
+          "columns": [
+            {
+              "expression": "message_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "message_created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "room_message_reactions_user_id_users_id_fk": {
+          "name": "room_message_reactions_user_id_users_id_fk",
+          "tableFrom": "room_message_reactions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "room_message_reactions_message_id_message_created_at_user_id_key_pk": {
+          "name": "room_message_reactions_message_id_message_created_at_user_id_key_pk",
+          "columns": [
+            "message_id",
+            "message_created_at",
+            "user_id",
+            "key"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "room_message_reactions_key_ck": {
+          "name": "room_message_reactions_key_ck",
+          "value": "\"room_message_reactions\".\"key\" IN ('up', 'heart', 'haha', 'wow', 'thanks', 'done')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.room_messages": {
+      "name": "room_messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_system": {
+          "name": "is_system",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "reply_to_id": {
+          "name": "reply_to_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "edited_at": {
+          "name": "edited_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_by_id": {
+          "name": "deleted_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "room_messages_conversation_idx": {
+          "name": "room_messages_conversation_idx",
+          "columns": [
+            {
+              "expression": "conversation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "room_messages_conversation_id_conversations_id_fk": {
+          "name": "room_messages_conversation_id_conversations_id_fk",
+          "tableFrom": "room_messages",
+          "tableTo": "conversations",
+          "columnsFrom": [
+            "conversation_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "room_messages_author_id_users_id_fk": {
+          "name": "room_messages_author_id_users_id_fk",
+          "tableFrom": "room_messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "room_messages_deleted_by_id_users_id_fk": {
+          "name": "room_messages_deleted_by_id_users_id_fk",
+          "tableFrom": "room_messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "deleted_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "room_messages_id_created_at_pk": {
+          "name": "room_messages_id_created_at_pk",
+          "columns": [
+            "id",
+            "created_at"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.room_mutes": {
+      "name": "room_mutes",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "until": {
+          "name": "until",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "by_id": {
+          "name": "by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "room_mutes_until_idx": {
+          "name": "room_mutes_until_idx",
+          "columns": [
+            {
+              "expression": "until",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "room_mutes_user_id_users_id_fk": {
+          "name": "room_mutes_user_id_users_id_fk",
+          "tableFrom": "room_mutes",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "room_mutes_by_id_users_id_fk": {
+          "name": "room_mutes_by_id_users_id_fk",
+          "tableFrom": "room_mutes",
+          "tableTo": "users",
+          "columnsFrom": [
+            "by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.saved_searches": {
+      "name": "saved_searches",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "label": {
+          "name": "label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "query": {
+          "name": "query",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tsquery": {
+          "name": "tsquery",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tags": {
+          "name": "tags",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "imdb_id": {
+          "name": "imdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tmdb_id": {
+          "name": "tmdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tvdb_id": {
+          "name": "tvdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notify": {
+          "name": "notify",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_matched_at": {
+          "name": "last_matched_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "match_count": {
+          "name": "match_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "seen_count": {
+          "name": "seen_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "saved_searches_category_idx": {
+          "name": "saved_searches_category_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "saved_searches_user_idx": {
+          "name": "saved_searches_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "saved_searches_notify_idx": {
+          "name": "saved_searches_notify_idx",
+          "columns": [
+            {
+              "expression": "notify",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"saved_searches\".\"notify\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "saved_searches_user_id_users_id_fk": {
+          "name": "saved_searches_user_id_users_id_fk",
+          "tableFrom": "saved_searches",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "saved_searches_category_id_categories_id_fk": {
+          "name": "saved_searches_category_id_categories_id_fk",
+          "tableFrom": "saved_searches",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.settings": {
+      "name": "settings",
+      "schema": "",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.shop_items": {
+      "name": "shop_items",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "payload": {
+          "name": "payload",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cost": {
+          "name": "cost",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "stock": {
+          "name": "stock",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "shop_items_enabled_idx": {
+          "name": "shop_items_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.shop_purchases": {
+      "name": "shop_purchases",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "item_id": {
+          "name": "item_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "item_name_snapshot": {
+          "name": "item_name_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "item_type_snapshot": {
+          "name": "item_type_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cost_paid": {
+          "name": "cost_paid",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "shop_purchases_user_idx": {
+          "name": "shop_purchases_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "shop_purchases_item_idx": {
+          "name": "shop_purchases_item_idx",
+          "columns": [
+            {
+              "expression": "item_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "shop_purchases_user_id_users_id_fk": {
+          "name": "shop_purchases_user_id_users_id_fk",
+          "tableFrom": "shop_purchases",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "shop_purchases_item_id_shop_items_id_fk": {
+          "name": "shop_purchases_item_id_shop_items_id_fk",
+          "tableFrom": "shop_purchases",
+          "tableTo": "shop_items",
+          "columnsFrom": [
+            "item_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.site_stats": {
+      "name": "site_stats",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "users_count": {
+          "name": "users_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrents_count": {
+          "name": "torrents_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peers_count": {
+          "name": "peers_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "seeders_count": {
+          "name": "seeders_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "redis_memory_usage": {
+          "name": "redis_memory_usage",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "db_size": {
+          "name": "db_size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total_uploaded_bytes": {
+          "name": "total_uploaded_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "site_stats_created_at_idx": {
+          "name": "site_stats_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tags": {
+      "name": "tags",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "color": {
+          "name": "color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'#6b7280'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "tags_fts_name_idx": {
+          "name": "tags_fts_name_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('simple', coalesce(\"name\", ''))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "tags_name_unique": {
+          "name": "tags_name_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "name"
+          ]
+        },
+        "tags_slug_unique": {
+          "name": "tags_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.themes": {
+      "name": "themes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "base": {
+          "name": "base",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'dark'"
+        },
+        "tokens": {
+          "name": "tokens",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "custom_css": {
+          "name": "custom_css",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "visibility": {
+          "name": "visibility",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'site'"
+        },
+        "required_roles": {
+          "name": "required_roles",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "themes_enabled_idx": {
+          "name": "themes_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "position",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "themes_created_by_users_id_fk": {
+          "name": "themes_created_by_users_id_fk",
+          "tableFrom": "themes",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "themes_slug_unique": {
+          "name": "themes_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "themes_visibility_ck": {
+          "name": "themes_visibility_ck",
+          "value": "(\"themes\".\"visibility\" = 'site' AND \"themes\".\"required_roles\" IS NULL)\n          OR (\"themes\".\"visibility\" = 'roles' AND jsonb_array_length(\"themes\".\"required_roles\") > 0)"
+        },
+        "themes_base_ck": {
+          "name": "themes_base_ck",
+          "value": "\"themes\".\"base\" IN ('light', 'dark')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.ticket_messages": {
+      "name": "ticket_messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "ticket_id": {
+          "name": "ticket_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "author_name": {
+          "name": "author_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "from_staff": {
+          "name": "from_staff",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "ticket_messages_author_idx": {
+          "name": "ticket_messages_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "ticket_messages_ticket_idx": {
+          "name": "ticket_messages_ticket_idx",
+          "columns": [
+            {
+              "expression": "ticket_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "ticket_messages_ticket_id_tickets_id_fk": {
+          "name": "ticket_messages_ticket_id_tickets_id_fk",
+          "tableFrom": "ticket_messages",
+          "tableTo": "tickets",
+          "columnsFrom": [
+            "ticket_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "ticket_messages_author_id_users_id_fk": {
+          "name": "ticket_messages_author_id_users_id_fk",
+          "tableFrom": "ticket_messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tickets": {
+      "name": "tickets",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "number": {
+          "name": "number",
+          "type": "serial",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "opened_by_id": {
+          "name": "opened_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "opened_by_name": {
+          "name": "opened_by_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'other'"
+        },
+        "subject": {
+          "name": "subject",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'open'"
+        },
+        "closure_reason": {
+          "name": "closure_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "idle_notice_at": {
+          "name": "idle_notice_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "assigned_to_id": {
+          "name": "assigned_to_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "assigned_to_name": {
+          "name": "assigned_to_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "assigned_at": {
+          "name": "assigned_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "closed_by_id": {
+          "name": "closed_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "closed_by_name": {
+          "name": "closed_by_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "closed_at": {
+          "name": "closed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "closing_note": {
+          "name": "closing_note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_message_at": {
+          "name": "last_message_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_message_by": {
+          "name": "last_message_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'member'"
+        }
+      },
+      "indexes": {
+        "tickets_number_idx": {
+          "name": "tickets_number_idx",
+          "columns": [
+            {
+              "expression": "number",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "tickets_status_idx": {
+          "name": "tickets_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "last_message_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "tickets_opened_by_idx": {
+          "name": "tickets_opened_by_idx",
+          "columns": [
+            {
+              "expression": "opened_by_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "tickets_opened_by_id_users_id_fk": {
+          "name": "tickets_opened_by_id_users_id_fk",
+          "tableFrom": "tickets",
+          "tableTo": "users",
+          "columnsFrom": [
+            "opened_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "tickets_assigned_to_id_users_id_fk": {
+          "name": "tickets_assigned_to_id_users_id_fk",
+          "tableFrom": "tickets",
+          "tableTo": "users",
+          "columnsFrom": [
+            "assigned_to_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "tickets_closed_by_id_users_id_fk": {
+          "name": "tickets_closed_by_id_users_id_fk",
+          "tableFrom": "tickets",
+          "tableTo": "users",
+          "columnsFrom": [
+            "closed_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "tickets_status_ck": {
+          "name": "tickets_status_ck",
+          "value": "\"tickets\".\"status\" IN ('open', 'closed')"
+        },
+        "tickets_closure_ck": {
+          "name": "tickets_closure_ck",
+          "value": "\"tickets\".\"closure_reason\" IS NULL\n          OR \"tickets\".\"closure_reason\"\n             IN ('resolved', 'rejected', 'stale', 'withdrawn')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.torrent_comments": {
+      "name": "torrent_comments",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_comments_torrent_idx": {
+          "name": "torrent_comments_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrent_comments_author_idx": {
+          "name": "torrent_comments_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_comments_torrent_id_torrents_id_fk": {
+          "name": "torrent_comments_torrent_id_torrents_id_fk",
+          "tableFrom": "torrent_comments",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "torrent_comments_author_id_users_id_fk": {
+          "name": "torrent_comments_author_id_users_id_fk",
+          "tableFrom": "torrent_comments",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_favorites": {
+      "name": "torrent_favorites",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_favorites_torrent_idx": {
+          "name": "torrent_favorites_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrent_favorites_user_created_idx": {
+          "name": "torrent_favorites_user_created_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_favorites_user_id_users_id_fk": {
+          "name": "torrent_favorites_user_id_users_id_fk",
+          "tableFrom": "torrent_favorites",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "torrent_favorites_torrent_id_torrents_id_fk": {
+          "name": "torrent_favorites_torrent_id_torrents_id_fk",
+          "tableFrom": "torrent_favorites",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "torrent_favorites_user_id_torrent_id_pk": {
+          "name": "torrent_favorites_user_id_torrent_id_pk",
+          "columns": [
+            "user_id",
+            "torrent_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_moderation_messages": {
+      "name": "torrent_moderation_messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_system": {
+          "name": "is_system",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "status_change": {
+          "name": "status_change",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_mod_messages_torrent_idx": {
+          "name": "torrent_mod_messages_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrent_mod_messages_author_idx": {
+          "name": "torrent_mod_messages_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_moderation_messages_torrent_id_torrents_id_fk": {
+          "name": "torrent_moderation_messages_torrent_id_torrents_id_fk",
+          "tableFrom": "torrent_moderation_messages",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "torrent_moderation_messages_author_id_users_id_fk": {
+          "name": "torrent_moderation_messages_author_id_users_id_fk",
+          "tableFrom": "torrent_moderation_messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_stats": {
+      "name": "torrent_stats",
+      "schema": "",
+      "columns": {
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "seeders": {
+          "name": "seeders",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "leechers": {
+          "name": "leechers",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "completed": {
+          "name": "completed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_stats_completed_idx": {
+          "name": "torrent_stats_completed_idx",
+          "columns": [
+            {
+              "expression": "\"completed\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrent_stats_seeders_idx": {
+          "name": "torrent_stats_seeders_idx",
+          "columns": [
+            {
+              "expression": "\"seeders\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_stats_info_hash_torrents_info_hash_fk": {
+          "name": "torrent_stats_info_hash_torrents_info_hash_fk",
+          "tableFrom": "torrent_stats",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "info_hash"
+          ],
+          "columnsTo": [
+            "info_hash"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_stats_history": {
+      "name": "torrent_stats_history",
+      "schema": "",
+      "columns": {
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "day": {
+          "name": "day",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "seeders": {
+          "name": "seeders",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "leechers": {
+          "name": "leechers",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "torrent_stats_history_info_hash_torrents_info_hash_fk": {
+          "name": "torrent_stats_history_info_hash_torrents_info_hash_fk",
+          "tableFrom": "torrent_stats_history",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "info_hash"
+          ],
+          "columnsTo": [
+            "info_hash"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "torrent_stats_history_info_hash_day_pk": {
+          "name": "torrent_stats_history_info_hash_day_pk",
+          "columns": [
+            "info_hash",
+            "day"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_tags": {
+      "name": "torrent_tags",
+      "schema": "",
+      "columns": {
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tag_id": {
+          "name": "tag_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_tags_tag_idx": {
+          "name": "torrent_tags_tag_idx",
+          "columns": [
+            {
+              "expression": "tag_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_tags_torrent_id_torrents_id_fk": {
+          "name": "torrent_tags_torrent_id_torrents_id_fk",
+          "tableFrom": "torrent_tags",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "torrent_tags_tag_id_tags_id_fk": {
+          "name": "torrent_tags_tag_id_tags_id_fk",
+          "tableFrom": "torrent_tags",
+          "tableTo": "tags",
+          "columnsFrom": [
+            "tag_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "torrent_tags_torrent_id_tag_id_pk": {
+          "name": "torrent_tags_torrent_id_tag_id_pk",
+          "columns": [
+            "torrent_id",
+            "tag_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrents": {
+      "name": "torrents",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size": {
+          "name": "size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "nfo": {
+          "name": "nfo",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "torrent_data": {
+          "name": "torrent_data",
+          "type": "bytea",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "uploader_id": {
+          "name": "uploader_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "imdb_id": {
+          "name": "imdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tmdb_id": {
+          "name": "tmdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tvdb_id": {
+          "name": "tvdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "igdb_id": {
+          "name": "igdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "openlibrary_id": {
+          "name": "openlibrary_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "season": {
+          "name": "season",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "episode": {
+          "name": "episode",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content_signature": {
+          "name": "content_signature",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "info_hash_v2": {
+          "name": "info_hash_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content_root_v2": {
+          "name": "content_root_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "download_multiplier": {
+          "name": "download_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 100
+        },
+        "upload_multiplier": {
+          "name": "upload_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 100
+        },
+        "multipliers_until": {
+          "name": "multipliers_until",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_sticky": {
+          "name": "is_sticky",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "superseded_by_id": {
+          "name": "superseded_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "superseded_at": {
+          "name": "superseded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "supersede_reason": {
+          "name": "supersede_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "federate_swarm": {
+          "name": "federate_swarm",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "moderation_status": {
+          "name": "moderation_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "moderated_by_id": {
+          "name": "moderated_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "moderated_at": {
+          "name": "moderated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "torrents_info_hash_idx": {
+          "name": "torrents_info_hash_idx",
+          "columns": [
+            {
+              "expression": "info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_updated_at_idx": {
+          "name": "torrents_updated_at_idx",
+          "columns": [
+            {
+              "expression": "updated_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_uploader_idx": {
+          "name": "torrents_uploader_idx",
+          "columns": [
+            {
+              "expression": "uploader_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_category_idx": {
+          "name": "torrents_category_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_imdb_idx": {
+          "name": "torrents_imdb_idx",
+          "columns": [
+            {
+              "expression": "imdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_tmdb_idx": {
+          "name": "torrents_tmdb_idx",
+          "columns": [
+            {
+              "expression": "tmdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_tmdb_season_idx": {
+          "name": "torrents_tmdb_season_idx",
+          "columns": [
+            {
+              "expression": "tmdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "season",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_grouped_idx": {
+          "name": "torrents_grouped_idx",
+          "columns": [
+            {
+              "expression": "coalesce(\"moderated_at\", \"created_at\") DESC",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"moderation_status\" = 'accepted' AND \"torrents\".\"is_active\" AND (\"torrents\".\"tmdb_id\" IS NOT NULL OR \"torrents\".\"igdb_id\" IS NOT NULL OR \"torrents\".\"openlibrary_id\" IS NOT NULL)",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_ungrouped_idx": {
+          "name": "torrents_ungrouped_idx",
+          "columns": [
+            {
+              "expression": "coalesce(\"moderated_at\", \"created_at\") DESC",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"moderation_status\" = 'accepted' AND \"torrents\".\"is_active\" AND \"torrents\".\"tmdb_id\" IS NULL AND \"torrents\".\"igdb_id\" IS NULL AND \"torrents\".\"openlibrary_id\" IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_tvdb_idx": {
+          "name": "torrents_tvdb_idx",
+          "columns": [
+            {
+              "expression": "tvdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_igdb_idx": {
+          "name": "torrents_igdb_idx",
+          "columns": [
+            {
+              "expression": "igdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_content_signature_idx": {
+          "name": "torrents_content_signature_idx",
+          "columns": [
+            {
+              "expression": "content_signature",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_superseded_by_idx": {
+          "name": "torrents_superseded_by_idx",
+          "columns": [
+            {
+              "expression": "superseded_by_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"superseded_by_id\" IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_content_root_v2_idx": {
+          "name": "torrents_content_root_v2_idx",
+          "columns": [
+            {
+              "expression": "content_root_v2",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_info_hash_v2_short_idx": {
+          "name": "torrents_info_hash_v2_short_idx",
+          "columns": [
+            {
+              "expression": "left(\"info_hash_v2\", 40)",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"info_hash_v2\" IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_openlibrary_idx": {
+          "name": "torrents_openlibrary_idx",
+          "columns": [
+            {
+              "expression": "openlibrary_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_created_at_idx": {
+          "name": "torrents_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_sticky_idx": {
+          "name": "torrents_sticky_idx",
+          "columns": [
+            {
+              "expression": "is_sticky",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"is_sticky\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_moderation_status_idx": {
+          "name": "torrents_moderation_status_idx",
+          "columns": [
+            {
+              "expression": "moderation_status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_name_trgm_idx": {
+          "name": "torrents_name_trgm_idx",
+          "columns": [
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "torrents_fts_name_idx": {
+          "name": "torrents_fts_name_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('simple', coalesce(\"name\", ''))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "torrents_fts_description_idx": {
+          "name": "torrents_fts_description_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('simple', coalesce(\"description\", ''))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "torrents_fts_nfo_idx": {
+          "name": "torrents_fts_nfo_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('simple', coalesce(\"nfo\", ''))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "torrents_mint_cursor_idx": {
+          "name": "torrents_mint_cursor_idx",
+          "columns": [
+            {
+              "expression": "coalesce(\"updated_at\", \"created_at\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrents_uploader_id_users_id_fk": {
+          "name": "torrents_uploader_id_users_id_fk",
+          "tableFrom": "torrents",
+          "tableTo": "users",
+          "columnsFrom": [
+            "uploader_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "torrents_category_id_categories_id_fk": {
+          "name": "torrents_category_id_categories_id_fk",
+          "tableFrom": "torrents",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "torrents_superseded_by_id_torrents_id_fk": {
+          "name": "torrents_superseded_by_id_torrents_id_fk",
+          "tableFrom": "torrents",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "superseded_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "torrents_moderated_by_id_users_id_fk": {
+          "name": "torrents_moderated_by_id_users_id_fk",
+          "tableFrom": "torrents",
+          "tableTo": "users",
+          "columnsFrom": [
+            "moderated_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "torrents_info_hash_unique": {
+          "name": "torrents_info_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "info_hash"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "torrents_multipliers_sane": {
+          "name": "torrents_multipliers_sane",
+          "value": "\"torrents\".\"download_multiplier\" between 0 and 200 and \"torrents\".\"upload_multiplier\" between 0 and 1000"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.trusted_devices": {
+      "name": "trusted_devices",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token_hash": {
+          "name": "token_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "label": {
+          "name": "label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_used_at": {
+          "name": "last_used_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "trusted_devices_user_idx": {
+          "name": "trusted_devices_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "trusted_devices_expires_idx": {
+          "name": "trusted_devices_expires_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "trusted_devices_user_id_users_id_fk": {
+          "name": "trusted_devices_user_id_users_id_fk",
+          "tableFrom": "trusted_devices",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "trusted_devices_token_hash_unique": {
+          "name": "trusted_devices_token_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "token_hash"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_request_comments": {
+      "name": "upload_request_comments",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "request_id": {
+          "name": "request_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "edited_at": {
+          "name": "edited_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_by_id": {
+          "name": "deleted_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "upload_request_comments_request_idx": {
+          "name": "upload_request_comments_request_idx",
+          "columns": [
+            {
+              "expression": "request_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "upload_request_comments_request_id_upload_requests_id_fk": {
+          "name": "upload_request_comments_request_id_upload_requests_id_fk",
+          "tableFrom": "upload_request_comments",
+          "tableTo": "upload_requests",
+          "columnsFrom": [
+            "request_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "upload_request_comments_author_id_users_id_fk": {
+          "name": "upload_request_comments_author_id_users_id_fk",
+          "tableFrom": "upload_request_comments",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "upload_request_comments_deleted_by_id_users_id_fk": {
+          "name": "upload_request_comments_deleted_by_id_users_id_fk",
+          "tableFrom": "upload_request_comments",
+          "tableTo": "users",
+          "columnsFrom": [
+            "deleted_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_request_fill_attempts": {
+      "name": "upload_request_fill_attempts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "request_id": {
+          "name": "request_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'proposed'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "rejected_at": {
+          "name": "rejected_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "upload_request_fill_attempts_torrent_idx": {
+          "name": "upload_request_fill_attempts_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_request_fill_attempts_user_idx": {
+          "name": "upload_request_fill_attempts_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_request_fill_attempts_request_user_idx": {
+          "name": "upload_request_fill_attempts_request_user_idx",
+          "columns": [
+            {
+              "expression": "request_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_request_fill_attempts_active_unique": {
+          "name": "upload_request_fill_attempts_active_unique",
+          "columns": [
+            {
+              "expression": "request_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "status = 'proposed'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "upload_request_fill_attempts_request_id_upload_requests_id_fk": {
+          "name": "upload_request_fill_attempts_request_id_upload_requests_id_fk",
+          "tableFrom": "upload_request_fill_attempts",
+          "tableTo": "upload_requests",
+          "columnsFrom": [
+            "request_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "upload_request_fill_attempts_user_id_users_id_fk": {
+          "name": "upload_request_fill_attempts_user_id_users_id_fk",
+          "tableFrom": "upload_request_fill_attempts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "upload_request_fill_attempts_torrent_id_torrents_id_fk": {
+          "name": "upload_request_fill_attempts_torrent_id_torrents_id_fk",
+          "tableFrom": "upload_request_fill_attempts",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_requests": {
+      "name": "upload_requests",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "requester_id": {
+          "name": "requester_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reward_points": {
+          "name": "reward_points",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'requested'"
+        },
+        "filled_by_id": {
+          "name": "filled_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filled_torrent_id": {
+          "name": "filled_torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filled_at": {
+          "name": "filled_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "validated_at": {
+          "name": "validated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cancelled_at": {
+          "name": "cancelled_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "federated_peer_id": {
+          "name": "federated_peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "federated_info_hash": {
+          "name": "federated_info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "federated_content_root_v2": {
+          "name": "federated_content_root_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "upload_requests_category_idx": {
+          "name": "upload_requests_category_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_requests_status_idx": {
+          "name": "upload_requests_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_requests_federated_info_hash_idx": {
+          "name": "upload_requests_federated_info_hash_idx",
+          "columns": [
+            {
+              "expression": "federated_info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_requests_requester_idx": {
+          "name": "upload_requests_requester_idx",
+          "columns": [
+            {
+              "expression": "requester_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_requests_filled_at_idx": {
+          "name": "upload_requests_filled_at_idx",
+          "columns": [
+            {
+              "expression": "filled_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "upload_requests_requester_id_users_id_fk": {
+          "name": "upload_requests_requester_id_users_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "users",
+          "columnsFrom": [
+            "requester_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "upload_requests_category_id_categories_id_fk": {
+          "name": "upload_requests_category_id_categories_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "upload_requests_filled_by_id_users_id_fk": {
+          "name": "upload_requests_filled_by_id_users_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "users",
+          "columnsFrom": [
+            "filled_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "upload_requests_filled_torrent_id_torrents_id_fk": {
+          "name": "upload_requests_filled_torrent_id_torrents_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "filled_torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "upload_requests_federated_peer_id_federation_peers_id_fk": {
+          "name": "upload_requests_federated_peer_id_federation_peers_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "federated_peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_rule_category_patterns": {
+      "name": "upload_rule_category_patterns",
+      "schema": "",
+      "columns": {
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "pattern": {
+          "name": "pattern",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "upload_rule_category_patterns_category_id_categories_id_fk": {
+          "name": "upload_rule_category_patterns_category_id_categories_id_fk",
+          "tableFrom": "upload_rule_category_patterns",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_rules": {
+      "name": "upload_rules",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "'singleton'"
+        },
+        "nfo_required": {
+          "name": "nfo_required",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "description_required": {
+          "name": "description_required",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "description_min_length": {
+          "name": "description_min_length",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "title_pattern_enforced": {
+          "name": "title_pattern_enforced",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "title_blocklist": {
+          "name": "title_blocklist",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tmdb_id_required": {
+          "name": "tmdb_id_required",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "max_torrent_size": {
+          "name": "max_torrent_size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "staff_bypass": {
+          "name": "staff_bypass",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.uploaded_fonts": {
+      "name": "uploaded_fonts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "family": {
+          "name": "family",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "storage_key": {
+          "name": "storage_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "bytes": {
+          "name": "bytes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sha256": {
+          "name": "sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "uploaded_by": {
+          "name": "uploaded_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "uploaded_fonts_role_idx": {
+          "name": "uploaded_fonts_role_idx",
+          "columns": [
+            {
+              "expression": "role",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "uploaded_fonts_uploaded_by_users_id_fk": {
+          "name": "uploaded_fonts_uploaded_by_users_id_fk",
+          "tableFrom": "uploaded_fonts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "uploaded_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "uploaded_fonts_sha256_unique": {
+          "name": "uploaded_fonts_sha256_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "sha256"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "uploaded_fonts_role_ck": {
+          "name": "uploaded_fonts_role_ck",
+          "value": "\"uploaded_fonts\".\"role\" IN ('sans', 'mono', 'display')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_follows": {
+      "name": "user_follows",
+      "schema": "",
+      "columns": {
+        "follower_id": {
+          "name": "follower_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "following_id": {
+          "name": "following_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "user_follows_following_idx": {
+          "name": "user_follows_following_idx",
+          "columns": [
+            {
+              "expression": "following_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_follows_follower_id_users_id_fk": {
+          "name": "user_follows_follower_id_users_id_fk",
+          "tableFrom": "user_follows",
+          "tableTo": "users",
+          "columnsFrom": [
+            "follower_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_follows_following_id_users_id_fk": {
+          "name": "user_follows_following_id_users_id_fk",
+          "tableFrom": "user_follows",
+          "tableTo": "users",
+          "columnsFrom": [
+            "following_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_follows_follower_id_following_id_pk": {
+          "name": "user_follows_follower_id_following_id_pk",
+          "columns": [
+            "follower_id",
+            "following_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_message_keys": {
+      "name": "user_message_keys",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "alg": {
+          "name": "alg",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'ECDH-P256'"
+        },
+        "device_label": {
+          "name": "device_label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "user_message_keys_user_id_users_id_fk": {
+          "name": "user_message_keys_user_id_users_id_fk",
+          "tableFrom": "user_message_keys",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_notification_channels": {
+      "name": "user_notification_channels",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "channel_type": {
+          "name": "channel_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "user_config": {
+          "name": "user_config",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "last_test_status": {
+          "name": "last_test_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_test_error": {
+          "name": "last_test_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_tested_at": {
+          "name": "last_tested_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "consecutive_failures": {
+          "name": "consecutive_failures",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "user_notification_channels_user_type_unique": {
+          "name": "user_notification_channels_user_type_unique",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "channel_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_notification_channels_user_id_users_id_fk": {
+          "name": "user_notification_channels_user_id_users_id_fk",
+          "tableFrom": "user_notification_channels",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_notification_routing": {
+      "name": "user_notification_routing",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "channel_type": {
+          "name": "channel_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "user_notification_routing_pk": {
+          "name": "user_notification_routing_pk",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "user_notification_routing_user_idx": {
+          "name": "user_notification_routing_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_notification_routing_user_id_users_id_fk": {
+          "name": "user_notification_routing_user_id_users_id_fk",
+          "tableFrom": "user_notification_routing",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_roles": {
+      "name": "user_roles",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role_id": {
+          "name": "role_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "assigned_at": {
+          "name": "assigned_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "assigned_manually": {
+          "name": "assigned_manually",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        }
+      },
+      "indexes": {
+        "user_roles_role_idx": {
+          "name": "user_roles_role_idx",
+          "columns": [
+            {
+              "expression": "role_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_roles_user_id_users_id_fk": {
+          "name": "user_roles_user_id_users_id_fk",
+          "tableFrom": "user_roles",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_roles_role_id_roles_id_fk": {
+          "name": "user_roles_role_id_roles_id_fk",
+          "tableFrom": "user_roles",
+          "tableTo": "roles",
+          "columnsFrom": [
+            "role_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_roles_user_id_role_id_pk": {
+          "name": "user_roles_user_id_role_id_pk",
+          "columns": [
+            "user_id",
+            "role_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_signing_keys": {
+      "name": "user_signing_keys",
+      "schema": "",
+      "columns": {
+        "did": {
+          "name": "did",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "private_key_enc": {
+          "name": "private_key_enc",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "revoked_at": {
+          "name": "revoked_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "succeeded_by": {
+          "name": "succeeded_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "user_signing_keys_current": {
+          "name": "user_signing_keys_current",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "revoked_at IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "user_signing_keys_user_idx": {
+          "name": "user_signing_keys_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_signing_keys_user_id_users_id_fk": {
+          "name": "user_signing_keys_user_id_users_id_fk",
+          "tableFrom": "user_signing_keys",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "auth_salt": {
+          "name": "auth_salt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "auth_verifier": {
+          "name": "auth_verifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "passkey": {
+          "name": "passkey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rss_key": {
+          "name": "rss_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "api_key": {
+          "name": "api_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_admin": {
+          "name": "is_admin",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_moderator": {
+          "name": "is_moderator",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_owner": {
+          "name": "is_owner",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "session_epoch": {
+          "name": "session_epoch",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "is_banned": {
+          "name": "is_banned",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "banned_by_id": {
+          "name": "banned_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "banned_by_role": {
+          "name": "banned_by_role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "banned_until": {
+          "name": "banned_until",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ban_reason": {
+          "name": "ban_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_ip": {
+          "name": "last_ip",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "uploaded": {
+          "name": "uploaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "bonus_uploaded": {
+          "name": "bonus_uploaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "downloaded": {
+          "name": "downloaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "invites_remaining": {
+          "name": "invites_remaining",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "bonus_points": {
+          "name": "bonus_points",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "panic_password_hash": {
+          "name": "panic_password_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bio": {
+          "name": "bio",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "show_last_seen": {
+          "name": "show_last_seen",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "show_adult_content": {
+          "name": "show_adult_content",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "messaging_read_receipts": {
+          "name": "messaging_read_receipts",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "anonymous_uploads": {
+          "name": "anonymous_uploads",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "hide_download_history": {
+          "name": "hide_download_history",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "restrict_comments": {
+          "name": "restrict_comments",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "share_reputation_federated": {
+          "name": "share_reputation_federated",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "theme": {
+          "name": "theme",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "language": {
+          "name": "language",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'en'"
+        },
+        "totp_secret": {
+          "name": "totp_secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "totp_enabled": {
+          "name": "totp_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "trust_devices_enabled": {
+          "name": "trust_devices_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_seen": {
+          "name": "last_seen",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "users_owner_unique": {
+          "name": "users_owner_unique",
+          "columns": [
+            {
+              "expression": "is_owner",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"users\".\"is_owner\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "users_username_lower_unique": {
+          "name": "users_username_lower_unique",
+          "columns": [
+            {
+              "expression": "lower(\"username\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "users_username_unique": {
+          "name": "users_username_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "username"
+          ]
+        },
+        "users_passkey_unique": {
+          "name": "users_passkey_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "passkey"
+          ]
+        },
+        "users_rss_key_unique": {
+          "name": "users_rss_key_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "rss_key"
+          ]
+        },
+        "users_api_key_unique": {
+          "name": "users_api_key_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "api_key"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.webauthn_credentials": {
+      "name": "webauthn_credentials",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "credential_id": {
+          "name": "credential_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "counter": {
+          "name": "counter",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "transports": {
+          "name": "transports",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_used_at": {
+          "name": "last_used_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "webauthn_credentials_user_idx": {
+          "name": "webauthn_credentials_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "webauthn_credentials_user_id_users_id_fk": {
+          "name": "webauthn_credentials_user_id_users_id_fk",
+          "tableFrom": "webauthn_credentials",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "webauthn_credentials_credential_id_unique": {
+          "name": "webauthn_credentials_credential_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "credential_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
\ No newline at end of file
diff --git a/packages/db/src/migrations/meta/0075_snapshot.json b/packages/db/src/migrations/meta/0075_snapshot.json
new file mode 100644
index 00000000..c776455f
--- /dev/null
+++ b/packages/db/src/migrations/meta/0075_snapshot.json
@@ -0,0 +1,10595 @@
+{
+  "id": "bcee98a6-619a-407e-a65f-2fe8a5767013",
+  "prevId": "9f821a03-8c53-4b8b-ab1c-0b617b6a0b6b",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.announce_log": {
+      "name": "announce_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "event": {
+          "name": "event",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ip_hash": {
+          "name": "ip_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "port": {
+          "name": "port",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "uploaded": {
+          "name": "uploaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "downloaded": {
+          "name": "downloaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "left": {
+          "name": "left",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "announce_log_info_hash_idx": {
+          "name": "announce_log_info_hash_idx",
+          "columns": [
+            {
+              "expression": "info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "announce_log_created_at_idx": {
+          "name": "announce_log_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.anticheat_flags": {
+      "name": "anticheat_flags",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "severity": {
+          "name": "severity",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'medium'"
+        },
+        "details": {
+          "name": "details",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ip": {
+          "name": "ip",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "reviewed_at": {
+          "name": "reviewed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reviewed_by_id": {
+          "name": "reviewed_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "review_verdict": {
+          "name": "review_verdict",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "review_note": {
+          "name": "review_note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "anticheat_flags_torrent_idx": {
+          "name": "anticheat_flags_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "anticheat_flags_user_idx": {
+          "name": "anticheat_flags_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "anticheat_flags_unreviewed_idx": {
+          "name": "anticheat_flags_unreviewed_idx",
+          "columns": [
+            {
+              "expression": "reviewed_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "anticheat_flags_kind_idx": {
+          "name": "anticheat_flags_kind_idx",
+          "columns": [
+            {
+              "expression": "kind",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "anticheat_flags_no_leecher_open_unique": {
+          "name": "anticheat_flags_no_leecher_open_unique",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "kind = 'no_leecher' AND reviewed_at IS NULL AND torrent_id IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "anticheat_flags_user_id_users_id_fk": {
+          "name": "anticheat_flags_user_id_users_id_fk",
+          "tableFrom": "anticheat_flags",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "anticheat_flags_torrent_id_torrents_id_fk": {
+          "name": "anticheat_flags_torrent_id_torrents_id_fk",
+          "tableFrom": "anticheat_flags",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "anticheat_flags_reviewed_by_id_users_id_fk": {
+          "name": "anticheat_flags_reviewed_by_id_users_id_fk",
+          "tableFrom": "anticheat_flags",
+          "tableTo": "users",
+          "columnsFrom": [
+            "reviewed_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.audit_log": {
+      "name": "audit_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "actor_name": {
+          "name": "actor_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_role": {
+          "name": "actor_role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "method": {
+          "name": "method",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_type": {
+          "name": "target_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_label": {
+          "name": "target_label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "changes": {
+          "name": "changes",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status_code": {
+          "name": "status_code",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_ip_hash": {
+          "name": "actor_ip_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "audit_log_created_idx": {
+          "name": "audit_log_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "audit_log_actor_idx": {
+          "name": "audit_log_actor_idx",
+          "columns": [
+            {
+              "expression": "actor_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "audit_log_target_idx": {
+          "name": "audit_log_target_idx",
+          "columns": [
+            {
+              "expression": "target_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "target_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "audit_log_action_idx": {
+          "name": "audit_log_action_idx",
+          "columns": [
+            {
+              "expression": "action",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "audit_log_actor_id_users_id_fk": {
+          "name": "audit_log_actor_id_users_id_fk",
+          "tableFrom": "audit_log",
+          "tableTo": "users",
+          "columnsFrom": [
+            "actor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.banned_ips": {
+      "name": "banned_ips",
+      "schema": "",
+      "columns": {
+        "ip": {
+          "name": "ip",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_age_tiers": {
+      "name": "bonus_age_tiers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "min_age_days": {
+          "name": "min_age_days",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "multiplier": {
+          "name": "multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "bonus_age_tiers_threshold_idx": {
+          "name": "bonus_age_tiers_threshold_idx",
+          "columns": [
+            {
+              "expression": "min_age_days",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_age_tiers_enabled_idx": {
+          "name": "bonus_age_tiers_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_events": {
+      "name": "bonus_events",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "long_description": {
+          "name": "long_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "download_multiplier": {
+          "name": "download_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "upload_multiplier": {
+          "name": "upload_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "starts_at": {
+          "name": "starts_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ends_at": {
+          "name": "ends_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'manual'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "created_by_id": {
+          "name": "created_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "bonus_events_window_idx": {
+          "name": "bonus_events_window_idx",
+          "columns": [
+            {
+              "expression": "starts_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "ends_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_events_enabled_idx": {
+          "name": "bonus_events_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "bonus_events_created_by_id_users_id_fk": {
+          "name": "bonus_events_created_by_id_users_id_fk",
+          "tableFrom": "bonus_events",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_grants": {
+      "name": "bonus_grants",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "amount": {
+          "name": "amount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "bonus_grants_user_idx": {
+          "name": "bonus_grants_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_grants_source_user_torrent_idx": {
+          "name": "bonus_grants_source_user_torrent_idx",
+          "columns": [
+            {
+              "expression": "source",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_grants_first_seeder_unique_idx": {
+          "name": "bonus_grants_first_seeder_unique_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "source = 'first_seeder' AND torrent_id IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "bonus_grants_user_id_users_id_fk": {
+          "name": "bonus_grants_user_id_users_id_fk",
+          "tableFrom": "bonus_grants",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "bonus_grants_torrent_id_torrents_id_fk": {
+          "name": "bonus_grants_torrent_id_torrents_id_fk",
+          "tableFrom": "bonus_grants",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_rules": {
+      "name": "bonus_rules",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "config": {
+          "name": "config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "bonus_rules_kind_idx": {
+          "name": "bonus_rules_kind_idx",
+          "columns": [
+            {
+              "expression": "kind",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "bonus_rules_kind_unique": {
+          "name": "bonus_rules_kind_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "kind"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_seed_count_tiers": {
+      "name": "bonus_seed_count_tiers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "max_seeders": {
+          "name": "max_seeders",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "multiplier": {
+          "name": "multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "bonus_seed_count_tiers_threshold_idx": {
+          "name": "bonus_seed_count_tiers_threshold_idx",
+          "columns": [
+            {
+              "expression": "max_seeders",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_seed_count_tiers_enabled_idx": {
+          "name": "bonus_seed_count_tiers_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.catalog_records": {
+      "name": "catalog_records",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'torrent'"
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'local'"
+        },
+        "hops": {
+          "name": "hops",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "via": {
+          "name": "via",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content_hash": {
+          "name": "content_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "supersedes": {
+          "name": "supersedes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "superseded_at": {
+          "name": "superseded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "catalog_records_info_hash_idx": {
+          "name": "catalog_records_info_hash_idx",
+          "columns": [
+            {
+              "expression": "info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "catalog_records_created_idx": {
+          "name": "catalog_records_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "catalog_records_relayable_idx": {
+          "name": "catalog_records_relayable_idx",
+          "columns": [
+            {
+              "expression": "origin",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "hops",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "catalog_records_live_idx": {
+          "name": "catalog_records_live_idx",
+          "columns": [
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "superseded_at IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "catalog_records_current_idx": {
+          "name": "catalog_records_current_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "superseded_at IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "catalog_records_origin_ck": {
+          "name": "catalog_records_origin_ck",
+          "value": "\"catalog_records\".\"origin\" IN ('local', 'ingested')"
+        },
+        "catalog_records_kind_ck": {
+          "name": "catalog_records_kind_ck",
+          "value": "\"catalog_records\".\"kind\" IN ('torrent', 'tombstone', 'identity', 'revocation')"
+        },
+        "catalog_records_hops_ck": {
+          "name": "catalog_records_hops_ck",
+          "value": "\"catalog_records\".\"hops\" BETWEEN 0 AND 2"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.categories": {
+      "name": "categories",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parent_id": {
+          "name": "parent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "newznab_id": {
+          "name": "newznab_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_adult": {
+          "name": "is_adult",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "categories_parent_idx": {
+          "name": "categories_parent_idx",
+          "columns": [
+            {
+              "expression": "parent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "categories_slug_unique": {
+          "name": "categories_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.conversation_participants": {
+      "name": "conversation_participants",
+      "schema": "",
+      "columns": {
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "joined_at": {
+          "name": "joined_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_read_at": {
+          "name": "last_read_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "unread_count": {
+          "name": "unread_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "muted_until": {
+          "name": "muted_until",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "archived_at": {
+          "name": "archived_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "state": {
+          "name": "state",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'active'"
+        }
+      },
+      "indexes": {
+        "conversation_participants_inbox_idx": {
+          "name": "conversation_participants_inbox_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "state",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "archived_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "conversation_participants_conversation_id_conversations_id_fk": {
+          "name": "conversation_participants_conversation_id_conversations_id_fk",
+          "tableFrom": "conversation_participants",
+          "tableTo": "conversations",
+          "columnsFrom": [
+            "conversation_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "conversation_participants_user_id_users_id_fk": {
+          "name": "conversation_participants_user_id_users_id_fk",
+          "tableFrom": "conversation_participants",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "conversation_participants_conversation_id_user_id_pk": {
+          "name": "conversation_participants_conversation_id_user_id_pk",
+          "columns": [
+            "conversation_id",
+            "user_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "conversation_participants_state_ck": {
+          "name": "conversation_participants_state_ck",
+          "value": "\"conversation_participants\".\"state\" IN ('active', 'pending', 'blocked')"
+        },
+        "conversation_participants_unread_ck": {
+          "name": "conversation_participants_unread_ck",
+          "value": "\"conversation_participants\".\"unread_count\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.conversations": {
+      "name": "conversations",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "pinned_message_id": {
+          "name": "pinned_message_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pinned_at": {
+          "name": "pinned_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pinned_by_id": {
+          "name": "pinned_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "encrypted": {
+          "name": "encrypted",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_by_id": {
+          "name": "created_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_message_at": {
+          "name": "last_message_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "conversations_slug_idx": {
+          "name": "conversations_slug_idx",
+          "columns": [
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "conversations_last_message_idx": {
+          "name": "conversations_last_message_idx",
+          "columns": [
+            {
+              "expression": "last_message_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "conversations_created_by_id_users_id_fk": {
+          "name": "conversations_created_by_id_users_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "conversations_kind_ck": {
+          "name": "conversations_kind_ck",
+          "value": "\"conversations\".\"kind\" IN ('dm', 'room')"
+        },
+        "conversations_room_slug_ck": {
+          "name": "conversations_room_slug_ck",
+          "value": "(\"conversations\".\"kind\" = 'room') = (\"conversations\".\"slug\" IS NOT NULL)"
+        },
+        "conversations_room_plain_ck": {
+          "name": "conversations_room_plain_ck",
+          "value": "NOT (\"conversations\".\"kind\" = 'room' AND \"conversations\".\"encrypted\")"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.federated_follows": {
+      "name": "federated_follows",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "local_user_id": {
+          "name": "local_user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "remote_username": {
+          "name": "remote_username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "federated_follows_unique": {
+          "name": "federated_follows_unique",
+          "columns": [
+            {
+              "expression": "local_user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "remote_username",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "federated_follows_target_idx": {
+          "name": "federated_follows_target_idx",
+          "columns": [
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "remote_username",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "federated_follows_local_user_id_users_id_fk": {
+          "name": "federated_follows_local_user_id_users_id_fk",
+          "tableFrom": "federated_follows",
+          "tableTo": "users",
+          "columnsFrom": [
+            "local_user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "federated_follows_peer_id_federation_peers_id_fk": {
+          "name": "federated_follows_peer_id_federation_peers_id_fk",
+          "tableFrom": "federated_follows",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federated_identities": {
+      "name": "federated_identities",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "local_user_id": {
+          "name": "local_user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "remote_username": {
+          "name": "remote_username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "method": {
+          "name": "method",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'bio'"
+        },
+        "subject_did": {
+          "name": "subject_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "evidence": {
+          "name": "evidence",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "verify_code": {
+          "name": "verify_code",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "verified_at": {
+          "name": "verified_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "federated_identities_unique": {
+          "name": "federated_identities_unique",
+          "columns": [
+            {
+              "expression": "local_user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "remote_username",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "federated_identities_local_user_id_users_id_fk": {
+          "name": "federated_identities_local_user_id_users_id_fk",
+          "tableFrom": "federated_identities",
+          "tableTo": "users",
+          "columnsFrom": [
+            "local_user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "federated_identities_peer_id_federation_peers_id_fk": {
+          "name": "federated_identities_peer_id_federation_peers_id_fk",
+          "tableFrom": "federated_identities",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federation_config": {
+      "name": "federation_config",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "'singleton'"
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "relay_enabled": {
+          "name": "relay_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "discoverable": {
+          "name": "discoverable",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "instance_name": {
+          "name": "instance_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "public_url": {
+          "name": "public_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "instance_id": {
+          "name": "instance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "private_key_enc": {
+          "name": "private_key_enc",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "default_scopes": {
+          "name": "default_scopes",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"catalog\":false,\"social\":false,\"accounts\":false,\"swarm\":false}'::jsonb"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federation_credit_grants": {
+      "name": "federation_credit_grants",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "subject_did": {
+          "name": "subject_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "local_user_id": {
+          "name": "local_user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bytes": {
+          "name": "bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "period_start": {
+          "name": "period_start",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "period_end": {
+          "name": "period_end",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "federation_credit_grants_user_idx": {
+          "name": "federation_credit_grants_user_idx",
+          "columns": [
+            {
+              "expression": "local_user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "federation_credit_grants_period_idx": {
+          "name": "federation_credit_grants_period_idx",
+          "columns": [
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "subject_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "period_end",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "federation_credit_grants_created_idx": {
+          "name": "federation_credit_grants_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "federation_credit_grants_peer_id_federation_peers_id_fk": {
+          "name": "federation_credit_grants_peer_id_federation_peers_id_fk",
+          "tableFrom": "federation_credit_grants",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "federation_credit_grants_local_user_id_users_id_fk": {
+          "name": "federation_credit_grants_local_user_id_users_id_fk",
+          "tableFrom": "federation_credit_grants",
+          "tableTo": "users",
+          "columnsFrom": [
+            "local_user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federation_peers": {
+      "name": "federation_peers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "base_url": {
+          "name": "base_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "instance_id": {
+          "name": "instance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending_out'"
+        },
+        "shares_with_them": {
+          "name": "shares_with_them",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"catalog\":false,\"social\":false,\"accounts\":false,\"swarm\":false}'::jsonb"
+        },
+        "accepts_from_them": {
+          "name": "accepts_from_them",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"catalog\":false,\"social\":false,\"accounts\":false,\"swarm\":false}'::jsonb"
+        },
+        "last_handshake_at": {
+          "name": "last_handshake_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_seen_at": {
+          "name": "last_seen_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "protocol_version": {
+          "name": "protocol_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "federation_peers_status_idx": {
+          "name": "federation_peers_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "federation_peers_instance_id_unique": {
+          "name": "federation_peers_instance_id_unique",
+          "columns": [
+            {
+              "expression": "instance_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "instance_id IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "federation_peers_created_by_users_id_fk": {
+          "name": "federation_peers_created_by_users_id_fk",
+          "tableFrom": "federation_peers",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "federation_peers_base_url_unique": {
+          "name": "federation_peers_base_url_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "base_url"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federation_sync_state": {
+      "name": "federation_sync_state",
+      "schema": "",
+      "columns": {
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "resource": {
+          "name": "resource",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cursor": {
+          "name": "cursor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_run_at": {
+          "name": "last_run_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_status": {
+          "name": "last_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "items_synced": {
+          "name": "items_synced",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "federation_sync_state_peer_id_federation_peers_id_fk": {
+          "name": "federation_sync_state_peer_id_federation_peers_id_fk",
+          "tableFrom": "federation_sync_state",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "federation_sync_state_peer_id_resource_pk": {
+          "name": "federation_sync_state_peer_id_resource_pk",
+          "columns": [
+            "peer_id",
+            "resource"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.forum_categories": {
+      "name": "forum_categories",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "color": {
+          "name": "color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "order": {
+          "name": "order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.forum_posts": {
+      "name": "forum_posts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "topic_id": {
+          "name": "topic_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "forum_posts_topic_idx": {
+          "name": "forum_posts_topic_idx",
+          "columns": [
+            {
+              "expression": "topic_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "forum_posts_author_idx": {
+          "name": "forum_posts_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "forum_posts_topic_id_forum_topics_id_fk": {
+          "name": "forum_posts_topic_id_forum_topics_id_fk",
+          "tableFrom": "forum_posts",
+          "tableTo": "forum_topics",
+          "columnsFrom": [
+            "topic_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "forum_posts_author_id_users_id_fk": {
+          "name": "forum_posts_author_id_users_id_fk",
+          "tableFrom": "forum_posts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.forum_topics": {
+      "name": "forum_topics",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_pinned": {
+          "name": "is_pinned",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_locked": {
+          "name": "is_locked",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "forum_topics_category_idx": {
+          "name": "forum_topics_category_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "forum_topics_author_idx": {
+          "name": "forum_topics_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "forum_topics_category_id_forum_categories_id_fk": {
+          "name": "forum_topics_category_id_forum_categories_id_fk",
+          "tableFrom": "forum_topics",
+          "tableTo": "forum_categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "forum_topics_author_id_users_id_fk": {
+          "name": "forum_topics_author_id_users_id_fk",
+          "tableFrom": "forum_topics",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.freeleech_pool_config": {
+      "name": "freeleech_pool_config",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "points_target": {
+          "name": "points_target",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "freeleech_duration_days": {
+          "name": "freeleech_duration_days",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "contribution_min": {
+          "name": "contribution_min",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "max_per_user_bp": {
+          "name": "max_per_user_bp",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "preset_amounts": {
+          "name": "preset_amounts",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "event_title_template": {
+          "name": "event_title_template",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event_description_template": {
+          "name": "event_description_template",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event_long_description_template": {
+          "name": "event_long_description_template",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "freeleech_pool_config_singleton": {
+          "name": "freeleech_pool_config_singleton",
+          "columns": [
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "id = 1",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.freeleech_pool_contributions": {
+      "name": "freeleech_pool_contributions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "cycle_id": {
+          "name": "cycle_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "amount": {
+          "name": "amount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "freeleech_pool_contributions_user_idx": {
+          "name": "freeleech_pool_contributions_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "freeleech_pool_contributions_cycle_idx": {
+          "name": "freeleech_pool_contributions_cycle_idx",
+          "columns": [
+            {
+              "expression": "cycle_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "freeleech_pool_contributions_cycle_user_idx": {
+          "name": "freeleech_pool_contributions_cycle_user_idx",
+          "columns": [
+            {
+              "expression": "cycle_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "freeleech_pool_contributions_cycle_id_freeleech_pool_cycles_id_fk": {
+          "name": "freeleech_pool_contributions_cycle_id_freeleech_pool_cycles_id_fk",
+          "tableFrom": "freeleech_pool_contributions",
+          "tableTo": "freeleech_pool_cycles",
+          "columnsFrom": [
+            "cycle_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "freeleech_pool_contributions_user_id_users_id_fk": {
+          "name": "freeleech_pool_contributions_user_id_users_id_fk",
+          "tableFrom": "freeleech_pool_contributions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.freeleech_pool_cycles": {
+      "name": "freeleech_pool_cycles",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'filling'"
+        },
+        "target_snapshot": {
+          "name": "target_snapshot",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "duration_days_snapshot": {
+          "name": "duration_days_snapshot",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total_contributed": {
+          "name": "total_contributed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ends_at": {
+          "name": "ends_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "triggered_event_id": {
+          "name": "triggered_event_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_title": {
+          "name": "paused_event_title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_description": {
+          "name": "paused_event_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_long_description": {
+          "name": "paused_event_long_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_download_multiplier": {
+          "name": "paused_event_download_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_upload_multiplier": {
+          "name": "paused_event_upload_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_remaining_ms": {
+          "name": "paused_event_remaining_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_created_by_id": {
+          "name": "paused_event_created_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "waiting_on_event_id": {
+          "name": "waiting_on_event_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "closed_at": {
+          "name": "closed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "freeleech_pool_cycles_status_idx": {
+          "name": "freeleech_pool_cycles_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "freeleech_pool_cycles_open_unique": {
+          "name": "freeleech_pool_cycles_open_unique",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "status IN ('filling', 'full_queued', 'active')",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "freeleech_pool_cycles_triggered_event_id_bonus_events_id_fk": {
+          "name": "freeleech_pool_cycles_triggered_event_id_bonus_events_id_fk",
+          "tableFrom": "freeleech_pool_cycles",
+          "tableTo": "bonus_events",
+          "columnsFrom": [
+            "triggered_event_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "freeleech_pool_cycles_paused_event_created_by_id_users_id_fk": {
+          "name": "freeleech_pool_cycles_paused_event_created_by_id_users_id_fk",
+          "tableFrom": "freeleech_pool_cycles",
+          "tableTo": "users",
+          "columnsFrom": [
+            "paused_event_created_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "freeleech_pool_cycles_waiting_on_event_id_bonus_events_id_fk": {
+          "name": "freeleech_pool_cycles_waiting_on_event_id_bonus_events_id_fk",
+          "tableFrom": "freeleech_pool_cycles",
+          "tableTo": "bonus_events",
+          "columnsFrom": [
+            "waiting_on_event_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.freeleech_pool_windows": {
+      "name": "freeleech_pool_windows",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "starts_at": {
+          "name": "starts_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ends_at": {
+          "name": "ends_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "weekday_start": {
+          "name": "weekday_start",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "weekday_end": {
+          "name": "weekday_end",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "minute_start": {
+          "name": "minute_start",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "minute_end": {
+          "name": "minute_end",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "monthly_days": {
+          "name": "monthly_days",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year_month_start": {
+          "name": "year_month_start",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year_day_start": {
+          "name": "year_day_start",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year_month_end": {
+          "name": "year_month_end",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year_day_end": {
+          "name": "year_day_end",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "label": {
+          "name": "label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "freeleech_pool_windows_kind_idx": {
+          "name": "freeleech_pool_windows_kind_idx",
+          "columns": [
+            {
+              "expression": "kind",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "freeleech_pool_windows_oneoff_idx": {
+          "name": "freeleech_pool_windows_oneoff_idx",
+          "columns": [
+            {
+              "expression": "starts_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "ends_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.hnr_tracking": {
+      "name": "hnr_tracking",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "downloaded_at": {
+          "name": "downloaded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "seed_time": {
+          "name": "seed_time",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "required_seed_time": {
+          "name": "required_seed_time",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 86400
+        },
+        "is_hnr": {
+          "name": "is_hnr",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_exempt": {
+          "name": "is_exempt",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "uploaded": {
+          "name": "uploaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "downloaded": {
+          "name": "downloaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "hnr_downloaded_at_idx": {
+          "name": "hnr_downloaded_at_idx",
+          "columns": [
+            {
+              "expression": "downloaded_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_completed_at_idx": {
+          "name": "hnr_completed_at_idx",
+          "columns": [
+            {
+              "expression": "completed_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_torrent_idx": {
+          "name": "hnr_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_status_idx": {
+          "name": "hnr_status_idx",
+          "columns": [
+            {
+              "expression": "is_hnr",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"hnr_tracking\".\"is_hnr\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_user_torrent_idx": {
+          "name": "hnr_user_torrent_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_user_is_hnr_idx": {
+          "name": "hnr_user_is_hnr_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "is_hnr",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "hnr_tracking_user_id_users_id_fk": {
+          "name": "hnr_tracking_user_id_users_id_fk",
+          "tableFrom": "hnr_tracking",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "hnr_tracking_torrent_id_torrents_id_fk": {
+          "name": "hnr_tracking_torrent_id_torrents_id_fk",
+          "tableFrom": "hnr_tracking",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.invitations": {
+      "name": "invitations",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "code": {
+          "name": "code",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "used_by": {
+          "name": "used_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "used_at": {
+          "name": "used_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "invitations_created_by_idx": {
+          "name": "invitations_created_by_idx",
+          "columns": [
+            {
+              "expression": "created_by",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "invitations_used_by_idx": {
+          "name": "invitations_used_by_idx",
+          "columns": [
+            {
+              "expression": "used_by",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"invitations\".\"used_by\" IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "invitations_created_by_users_id_fk": {
+          "name": "invitations_created_by_users_id_fk",
+          "tableFrom": "invitations",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "invitations_used_by_users_id_fk": {
+          "name": "invitations_used_by_users_id_fk",
+          "tableFrom": "invitations",
+          "tableTo": "users",
+          "columnsFrom": [
+            "used_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "invitations_code_unique": {
+          "name": "invitations_code_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "code"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.login_events": {
+      "name": "login_events",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "method": {
+          "name": "method",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "outcome": {
+          "name": "outcome",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_hash": {
+          "name": "ip_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "login_events_user_idx": {
+          "name": "login_events_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "login_events_created_idx": {
+          "name": "login_events_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "login_events_user_id_users_id_fk": {
+          "name": "login_events_user_id_users_id_fk",
+          "tableFrom": "login_events",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.message_reactions": {
+      "name": "message_reactions",
+      "schema": "",
+      "columns": {
+        "message_id": {
+          "name": "message_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "message_reactions_user_idx": {
+          "name": "message_reactions_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "message_reactions_message_id_messages_id_fk": {
+          "name": "message_reactions_message_id_messages_id_fk",
+          "tableFrom": "message_reactions",
+          "tableTo": "messages",
+          "columnsFrom": [
+            "message_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "message_reactions_user_id_users_id_fk": {
+          "name": "message_reactions_user_id_users_id_fk",
+          "tableFrom": "message_reactions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "message_reactions_message_id_user_id_key_pk": {
+          "name": "message_reactions_message_id_user_id_key_pk",
+          "columns": [
+            "message_id",
+            "user_id",
+            "key"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "message_reactions_key_ck": {
+          "name": "message_reactions_key_ck",
+          "value": "\"message_reactions\".\"key\" IN ('up', 'heart', 'haha', 'wow', 'thanks', 'done')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.message_read_log": {
+      "name": "message_read_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "reader_id": {
+          "name": "reader_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reader_name": {
+          "name": "reader_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "message_id": {
+          "name": "message_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "report_id": {
+          "name": "report_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "disclosed": {
+          "name": "disclosed",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "message_read_log_created_idx": {
+          "name": "message_read_log_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "message_read_log_reader_idx": {
+          "name": "message_read_log_reader_idx",
+          "columns": [
+            {
+              "expression": "reader_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "message_read_log_message_idx": {
+          "name": "message_read_log_message_idx",
+          "columns": [
+            {
+              "expression": "message_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "message_read_log_reader_id_users_id_fk": {
+          "name": "message_read_log_reader_id_users_id_fk",
+          "tableFrom": "message_read_log",
+          "tableTo": "users",
+          "columnsFrom": [
+            "reader_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.messages": {
+      "name": "messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reply_to_id": {
+          "name": "reply_to_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cipher": {
+          "name": "cipher",
+          "type": "bytea",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "iv": {
+          "name": "iv",
+          "type": "bytea",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_system": {
+          "name": "is_system",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "edited_at": {
+          "name": "edited_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_by_id": {
+          "name": "deleted_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "messages_reply_to_idx": {
+          "name": "messages_reply_to_idx",
+          "columns": [
+            {
+              "expression": "reply_to_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "messages_author_idx": {
+          "name": "messages_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "messages_conversation_idx": {
+          "name": "messages_conversation_idx",
+          "columns": [
+            {
+              "expression": "conversation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "messages_conversation_id_conversations_id_fk": {
+          "name": "messages_conversation_id_conversations_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "conversations",
+          "columnsFrom": [
+            "conversation_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "messages_author_id_users_id_fk": {
+          "name": "messages_author_id_users_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "messages_reply_to_id_messages_id_fk": {
+          "name": "messages_reply_to_id_messages_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "messages",
+          "columnsFrom": [
+            "reply_to_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "messages_deleted_by_id_users_id_fk": {
+          "name": "messages_deleted_by_id_users_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "deleted_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "messages_payload_ck": {
+          "name": "messages_payload_ck",
+          "value": "\"messages\".\"deleted_at\" IS NOT NULL OR ((\"messages\".\"body\" IS NOT NULL) <> (\"messages\".\"cipher\" IS NOT NULL))"
+        },
+        "messages_cipher_iv_ck": {
+          "name": "messages_cipher_iv_ck",
+          "value": "(\"messages\".\"cipher\" IS NULL) = (\"messages\".\"iv\" IS NULL)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.messaging_blocks": {
+      "name": "messaging_blocks",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "blocked_id": {
+          "name": "blocked_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "messaging_blocks_blocked_idx": {
+          "name": "messaging_blocks_blocked_idx",
+          "columns": [
+            {
+              "expression": "blocked_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "messaging_blocks_user_id_users_id_fk": {
+          "name": "messaging_blocks_user_id_users_id_fk",
+          "tableFrom": "messaging_blocks",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "messaging_blocks_blocked_id_users_id_fk": {
+          "name": "messaging_blocks_blocked_id_users_id_fk",
+          "tableFrom": "messaging_blocks",
+          "tableTo": "users",
+          "columnsFrom": [
+            "blocked_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "messaging_blocks_user_id_blocked_id_pk": {
+          "name": "messaging_blocks_user_id_blocked_id_pk",
+          "columns": [
+            "user_id",
+            "blocked_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "messaging_blocks_self_ck": {
+          "name": "messaging_blocks_self_ck",
+          "value": "\"messaging_blocks\".\"user_id\" <> \"messaging_blocks\".\"blocked_id\""
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.messaging_broadcasts": {
+      "name": "messaging_broadcasts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "created_by_id": {
+          "name": "created_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "audience": {
+          "name": "audience",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total": {
+          "name": "total",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "sent": {
+          "name": "sent",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "finished_at": {
+          "name": "finished_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error": {
+          "name": "error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "messaging_broadcasts_created_idx": {
+          "name": "messaging_broadcasts_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "messaging_broadcasts_created_by_id_users_id_fk": {
+          "name": "messaging_broadcasts_created_by_id_users_id_fk",
+          "tableFrom": "messaging_broadcasts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notification_channels": {
+      "name": "notification_channels",
+      "schema": "",
+      "columns": {
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "server_config": {
+          "name": "server_config",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "last_test_status": {
+          "name": "last_test_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_test_error": {
+          "name": "last_test_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_tested_at": {
+          "name": "last_tested_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_by": {
+          "name": "updated_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "notification_channels_updated_by_users_id_fk": {
+          "name": "notification_channels_updated_by_users_id_fk",
+          "tableFrom": "notification_channels",
+          "tableTo": "users",
+          "columnsFrom": [
+            "updated_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notifications": {
+      "name": "notifications",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "payload": {
+          "name": "payload",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "link": {
+          "name": "link",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "read_at": {
+          "name": "read_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "notifications_user_created_idx": {
+          "name": "notifications_user_created_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "notifications_user_unread_idx": {
+          "name": "notifications_user_unread_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "read_at IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "notifications_user_id_users_id_fk": {
+          "name": "notifications_user_id_users_id_fk",
+          "tableFrom": "notifications",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.panic_state": {
+      "name": "panic_state",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "'singleton'"
+        },
+        "is_encrypted": {
+          "name": "is_encrypted",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "encrypted_at": {
+          "name": "encrypted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "encryption_salt": {
+          "name": "encryption_salt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "encryption_iv": {
+          "name": "encryption_iv",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "kdf_version": {
+          "name": "kdf_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "panic_password_hash": {
+          "name": "panic_password_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "phase": {
+          "name": "phase",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'idle'"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "panic_state_phase_ck": {
+          "name": "panic_state_phase_ck",
+          "value": "\"panic_state\".\"phase\" IN ('idle', 'encrypting', 'encrypted', 'restoring')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.presentation_templates": {
+      "name": "presentation_templates",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'universal'"
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "visibility": {
+          "name": "visibility",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'private'"
+        },
+        "is_default": {
+          "name": "is_default",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "presentation_templates_owner_idx": {
+          "name": "presentation_templates_owner_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "presentation_templates_site_idx": {
+          "name": "presentation_templates_site_idx",
+          "columns": [
+            {
+              "expression": "category",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"presentation_templates\".\"visibility\" = 'site'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "presentation_templates_default_unique": {
+          "name": "presentation_templates_default_unique",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"presentation_templates\".\"is_default\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "presentation_templates_owner_id_users_id_fk": {
+          "name": "presentation_templates_owner_id_users_id_fk",
+          "tableFrom": "presentation_templates",
+          "tableTo": "users",
+          "columnsFrom": [
+            "owner_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "presentation_templates_created_by_users_id_fk": {
+          "name": "presentation_templates_created_by_users_id_fk",
+          "tableFrom": "presentation_templates",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "presentation_templates_scope_ck": {
+          "name": "presentation_templates_scope_ck",
+          "value": "(\"presentation_templates\".\"visibility\" = 'private' AND \"presentation_templates\".\"owner_id\" IS NOT NULL)\n          OR (\"presentation_templates\".\"visibility\" = 'site' AND \"presentation_templates\".\"owner_id\" IS NULL AND \"presentation_templates\".\"is_default\" = false)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.record_sources": {
+      "name": "record_sources",
+      "schema": "",
+      "columns": {
+        "record_id": {
+          "name": "record_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'torrent'"
+        },
+        "first_seen_at": {
+          "name": "first_seen_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "record_sources_record_idx": {
+          "name": "record_sources_record_idx",
+          "columns": [
+            {
+              "expression": "record_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "record_sources_peer_id_federation_peers_id_fk": {
+          "name": "record_sources_peer_id_federation_peers_id_fk",
+          "tableFrom": "record_sources",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "record_sources_peer_id_record_id_pk": {
+          "name": "record_sources_peer_id_record_id_pk",
+          "columns": [
+            "peer_id",
+            "record_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.recovery_codes": {
+      "name": "recovery_codes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "code_hash": {
+          "name": "code_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "used_at": {
+          "name": "used_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "recovery_codes_user_idx": {
+          "name": "recovery_codes_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "recovery_codes_user_id_users_id_fk": {
+          "name": "recovery_codes_user_id_users_id_fk",
+          "tableFrom": "recovery_codes",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.remote_category_map": {
+      "name": "remote_category_map",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "remote_slug": {
+          "name": "remote_slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "local_category_id": {
+          "name": "local_category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "remote_category_map_slug_idx": {
+          "name": "remote_category_map_slug_idx",
+          "columns": [
+            {
+              "expression": "remote_slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_category_map_category_idx": {
+          "name": "remote_category_map_category_idx",
+          "columns": [
+            {
+              "expression": "local_category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "remote_category_map_local_category_id_categories_id_fk": {
+          "name": "remote_category_map_local_category_id_categories_id_fk",
+          "tableFrom": "remote_category_map",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "local_category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "remote_category_map_created_by_users_id_fk": {
+          "name": "remote_category_map_created_by_users_id_fk",
+          "tableFrom": "remote_category_map",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.remote_identity_links": {
+      "name": "remote_identity_links",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject_did": {
+          "name": "subject_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "alias_did": {
+          "name": "alias_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "evidence": {
+          "name": "evidence",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "record_id": {
+          "name": "record_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "remote_identity_links_unique": {
+          "name": "remote_identity_links_unique",
+          "columns": [
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "subject_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "alias_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_identity_links_subject_idx": {
+          "name": "remote_identity_links_subject_idx",
+          "columns": [
+            {
+              "expression": "subject_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_identity_links_alias_idx": {
+          "name": "remote_identity_links_alias_idx",
+          "columns": [
+            {
+              "expression": "alias_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "remote_identity_links_peer_id_federation_peers_id_fk": {
+          "name": "remote_identity_links_peer_id_federation_peers_id_fk",
+          "tableFrom": "remote_identity_links",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.remote_masks": {
+      "name": "remote_masks",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "remote_masks_scope_value_idx": {
+          "name": "remote_masks_scope_value_idx",
+          "columns": [
+            {
+              "expression": "scope",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "value",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_masks_value_idx": {
+          "name": "remote_masks_value_idx",
+          "columns": [
+            {
+              "expression": "value",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "remote_masks_created_by_users_id_fk": {
+          "name": "remote_masks_created_by_users_id_fk",
+          "tableFrom": "remote_masks",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.remote_torrents": {
+      "name": "remote_torrents",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "remote_id": {
+          "name": "remote_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content_signature": {
+          "name": "content_signature",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "info_hash_v2": {
+          "name": "info_hash_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content_root_v2": {
+          "name": "content_root_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size": {
+          "name": "size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category_slug": {
+          "name": "category_slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category_type": {
+          "name": "category_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_adult": {
+          "name": "is_adult",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "tags": {
+          "name": "tags",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "imdb_id": {
+          "name": "imdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tmdb_id": {
+          "name": "tmdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tvdb_id": {
+          "name": "tvdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "igdb_id": {
+          "name": "igdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "openlibrary_id": {
+          "name": "openlibrary_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "season": {
+          "name": "season",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "episode": {
+          "name": "episode",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "seeders": {
+          "name": "seeders",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "leechers": {
+          "name": "leechers",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "completed": {
+          "name": "completed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "record_id": {
+          "name": "record_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "author_did": {
+          "name": "author_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "verified": {
+          "name": "verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "uploader_name": {
+          "name": "uploader_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote_created_at": {
+          "name": "remote_created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote_detail_url": {
+          "name": "remote_detail_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote_download_url": {
+          "name": "remote_download_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "fetched_at": {
+          "name": "fetched_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "remote_torrents_peer_remote_unique": {
+          "name": "remote_torrents_peer_remote_unique",
+          "columns": [
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "remote_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_info_hash_idx": {
+          "name": "remote_torrents_info_hash_idx",
+          "columns": [
+            {
+              "expression": "info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_content_root_v2_idx": {
+          "name": "remote_torrents_content_root_v2_idx",
+          "columns": [
+            {
+              "expression": "content_root_v2",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_content_sig_idx": {
+          "name": "remote_torrents_content_sig_idx",
+          "columns": [
+            {
+              "expression": "content_signature",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_imdb_idx": {
+          "name": "remote_torrents_imdb_idx",
+          "columns": [
+            {
+              "expression": "imdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_tmdb_idx": {
+          "name": "remote_torrents_tmdb_idx",
+          "columns": [
+            {
+              "expression": "tmdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_igdb_idx": {
+          "name": "remote_torrents_igdb_idx",
+          "columns": [
+            {
+              "expression": "igdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_openlibrary_idx": {
+          "name": "remote_torrents_openlibrary_idx",
+          "columns": [
+            {
+              "expression": "openlibrary_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_record_idx": {
+          "name": "remote_torrents_record_idx",
+          "columns": [
+            {
+              "expression": "record_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_author_idx": {
+          "name": "remote_torrents_author_idx",
+          "columns": [
+            {
+              "expression": "author_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_name_idx": {
+          "name": "remote_torrents_name_idx",
+          "columns": [
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "remote_torrents_peer_id_federation_peers_id_fk": {
+          "name": "remote_torrents_peer_id_federation_peers_id_fk",
+          "tableFrom": "remote_torrents",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.reports": {
+      "name": "reports",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "reporter_id": {
+          "name": "reporter_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_type": {
+          "name": "target_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "details": {
+          "name": "details",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "withdrawn_at": {
+          "name": "withdrawn_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resolved_by": {
+          "name": "resolved_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resolved_at": {
+          "name": "resolved_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resolution": {
+          "name": "resolution",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "reports_reporter_idx": {
+          "name": "reports_reporter_idx",
+          "columns": [
+            {
+              "expression": "reporter_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reports_target_idx": {
+          "name": "reports_target_idx",
+          "columns": [
+            {
+              "expression": "target_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "target_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reports_status_idx": {
+          "name": "reports_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reports_reporter_id_users_id_fk": {
+          "name": "reports_reporter_id_users_id_fk",
+          "tableFrom": "reports",
+          "tableTo": "users",
+          "columnsFrom": [
+            "reporter_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reports_resolved_by_users_id_fk": {
+          "name": "reports_resolved_by_users_id_fk",
+          "tableFrom": "reports",
+          "tableTo": "users",
+          "columnsFrom": [
+            "resolved_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.revoked_identities": {
+      "name": "revoked_identities",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "did": {
+          "name": "did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "succeeded_by": {
+          "name": "succeeded_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "record_id": {
+          "name": "record_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "revoked_at": {
+          "name": "revoked_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "revoked_identities_unique": {
+          "name": "revoked_identities_unique",
+          "columns": [
+            {
+              "expression": "issuer",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "revoked_identities_did_idx": {
+          "name": "revoked_identities_did_idx",
+          "columns": [
+            {
+              "expression": "did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.roles": {
+      "name": "roles",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "color": {
+          "name": "color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'#6b7280'"
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "show_as_badge": {
+          "name": "show_as_badge",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "priority": {
+          "name": "priority",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "assignment_mode": {
+          "name": "assignment_mode",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'manual'"
+        },
+        "rules": {
+          "name": "rules",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "can_upload_without_moderation": {
+          "name": "can_upload_without_moderation",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "roles_name_unique": {
+          "name": "roles_name_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "name"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.room_message_reactions": {
+      "name": "room_message_reactions",
+      "schema": "",
+      "columns": {
+        "message_id": {
+          "name": "message_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "message_created_at": {
+          "name": "message_created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "room_message_reactions_user_idx": {
+          "name": "room_message_reactions_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "room_message_reactions_message_idx": {
+          "name": "room_message_reactions_message_idx",
+          "columns": [
+            {
+              "expression": "message_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "message_created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "room_message_reactions_user_id_users_id_fk": {
+          "name": "room_message_reactions_user_id_users_id_fk",
+          "tableFrom": "room_message_reactions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "room_message_reactions_message_id_message_created_at_user_id_key_pk": {
+          "name": "room_message_reactions_message_id_message_created_at_user_id_key_pk",
+          "columns": [
+            "message_id",
+            "message_created_at",
+            "user_id",
+            "key"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "room_message_reactions_key_ck": {
+          "name": "room_message_reactions_key_ck",
+          "value": "\"room_message_reactions\".\"key\" IN ('up', 'heart', 'haha', 'wow', 'thanks', 'done')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.room_messages": {
+      "name": "room_messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_system": {
+          "name": "is_system",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "reply_to_id": {
+          "name": "reply_to_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "edited_at": {
+          "name": "edited_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_by_id": {
+          "name": "deleted_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "room_messages_conversation_idx": {
+          "name": "room_messages_conversation_idx",
+          "columns": [
+            {
+              "expression": "conversation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "room_messages_conversation_id_conversations_id_fk": {
+          "name": "room_messages_conversation_id_conversations_id_fk",
+          "tableFrom": "room_messages",
+          "tableTo": "conversations",
+          "columnsFrom": [
+            "conversation_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "room_messages_author_id_users_id_fk": {
+          "name": "room_messages_author_id_users_id_fk",
+          "tableFrom": "room_messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "room_messages_deleted_by_id_users_id_fk": {
+          "name": "room_messages_deleted_by_id_users_id_fk",
+          "tableFrom": "room_messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "deleted_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "room_messages_id_created_at_pk": {
+          "name": "room_messages_id_created_at_pk",
+          "columns": [
+            "id",
+            "created_at"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.room_mutes": {
+      "name": "room_mutes",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "until": {
+          "name": "until",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "by_id": {
+          "name": "by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "room_mutes_until_idx": {
+          "name": "room_mutes_until_idx",
+          "columns": [
+            {
+              "expression": "until",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "room_mutes_user_id_users_id_fk": {
+          "name": "room_mutes_user_id_users_id_fk",
+          "tableFrom": "room_mutes",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "room_mutes_by_id_users_id_fk": {
+          "name": "room_mutes_by_id_users_id_fk",
+          "tableFrom": "room_mutes",
+          "tableTo": "users",
+          "columnsFrom": [
+            "by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.saved_searches": {
+      "name": "saved_searches",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "label": {
+          "name": "label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "query": {
+          "name": "query",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tsquery": {
+          "name": "tsquery",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tags": {
+          "name": "tags",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "imdb_id": {
+          "name": "imdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tmdb_id": {
+          "name": "tmdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tvdb_id": {
+          "name": "tvdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notify": {
+          "name": "notify",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_matched_at": {
+          "name": "last_matched_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "match_count": {
+          "name": "match_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "seen_count": {
+          "name": "seen_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "saved_searches_category_idx": {
+          "name": "saved_searches_category_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "saved_searches_user_idx": {
+          "name": "saved_searches_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "saved_searches_notify_idx": {
+          "name": "saved_searches_notify_idx",
+          "columns": [
+            {
+              "expression": "notify",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"saved_searches\".\"notify\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "saved_searches_user_id_users_id_fk": {
+          "name": "saved_searches_user_id_users_id_fk",
+          "tableFrom": "saved_searches",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "saved_searches_category_id_categories_id_fk": {
+          "name": "saved_searches_category_id_categories_id_fk",
+          "tableFrom": "saved_searches",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.settings": {
+      "name": "settings",
+      "schema": "",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.shop_items": {
+      "name": "shop_items",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "payload": {
+          "name": "payload",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cost": {
+          "name": "cost",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "stock": {
+          "name": "stock",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "shop_items_enabled_idx": {
+          "name": "shop_items_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.shop_purchases": {
+      "name": "shop_purchases",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "item_id": {
+          "name": "item_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "item_name_snapshot": {
+          "name": "item_name_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "item_type_snapshot": {
+          "name": "item_type_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cost_paid": {
+          "name": "cost_paid",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "shop_purchases_user_idx": {
+          "name": "shop_purchases_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "shop_purchases_item_idx": {
+          "name": "shop_purchases_item_idx",
+          "columns": [
+            {
+              "expression": "item_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "shop_purchases_user_id_users_id_fk": {
+          "name": "shop_purchases_user_id_users_id_fk",
+          "tableFrom": "shop_purchases",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "shop_purchases_item_id_shop_items_id_fk": {
+          "name": "shop_purchases_item_id_shop_items_id_fk",
+          "tableFrom": "shop_purchases",
+          "tableTo": "shop_items",
+          "columnsFrom": [
+            "item_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.site_stats": {
+      "name": "site_stats",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "users_count": {
+          "name": "users_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrents_count": {
+          "name": "torrents_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peers_count": {
+          "name": "peers_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "seeders_count": {
+          "name": "seeders_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "redis_memory_usage": {
+          "name": "redis_memory_usage",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "db_size": {
+          "name": "db_size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total_uploaded_bytes": {
+          "name": "total_uploaded_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "site_stats_created_at_idx": {
+          "name": "site_stats_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tags": {
+      "name": "tags",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "color": {
+          "name": "color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'#6b7280'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "tags_fts_name_idx": {
+          "name": "tags_fts_name_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('simple', coalesce(translate(\"name\", '._', '  '), ''))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "tags_name_unique": {
+          "name": "tags_name_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "name"
+          ]
+        },
+        "tags_slug_unique": {
+          "name": "tags_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.themes": {
+      "name": "themes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "base": {
+          "name": "base",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'dark'"
+        },
+        "tokens": {
+          "name": "tokens",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "custom_css": {
+          "name": "custom_css",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "visibility": {
+          "name": "visibility",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'site'"
+        },
+        "required_roles": {
+          "name": "required_roles",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "themes_enabled_idx": {
+          "name": "themes_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "position",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "themes_created_by_users_id_fk": {
+          "name": "themes_created_by_users_id_fk",
+          "tableFrom": "themes",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "themes_slug_unique": {
+          "name": "themes_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "themes_visibility_ck": {
+          "name": "themes_visibility_ck",
+          "value": "(\"themes\".\"visibility\" = 'site' AND \"themes\".\"required_roles\" IS NULL)\n          OR (\"themes\".\"visibility\" = 'roles' AND jsonb_array_length(\"themes\".\"required_roles\") > 0)"
+        },
+        "themes_base_ck": {
+          "name": "themes_base_ck",
+          "value": "\"themes\".\"base\" IN ('light', 'dark')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.ticket_messages": {
+      "name": "ticket_messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "ticket_id": {
+          "name": "ticket_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "author_name": {
+          "name": "author_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "from_staff": {
+          "name": "from_staff",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "ticket_messages_author_idx": {
+          "name": "ticket_messages_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "ticket_messages_ticket_idx": {
+          "name": "ticket_messages_ticket_idx",
+          "columns": [
+            {
+              "expression": "ticket_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "ticket_messages_ticket_id_tickets_id_fk": {
+          "name": "ticket_messages_ticket_id_tickets_id_fk",
+          "tableFrom": "ticket_messages",
+          "tableTo": "tickets",
+          "columnsFrom": [
+            "ticket_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "ticket_messages_author_id_users_id_fk": {
+          "name": "ticket_messages_author_id_users_id_fk",
+          "tableFrom": "ticket_messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tickets": {
+      "name": "tickets",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "number": {
+          "name": "number",
+          "type": "serial",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "opened_by_id": {
+          "name": "opened_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "opened_by_name": {
+          "name": "opened_by_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'other'"
+        },
+        "subject": {
+          "name": "subject",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'open'"
+        },
+        "closure_reason": {
+          "name": "closure_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "idle_notice_at": {
+          "name": "idle_notice_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "assigned_to_id": {
+          "name": "assigned_to_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "assigned_to_name": {
+          "name": "assigned_to_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "assigned_at": {
+          "name": "assigned_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "closed_by_id": {
+          "name": "closed_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "closed_by_name": {
+          "name": "closed_by_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "closed_at": {
+          "name": "closed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "closing_note": {
+          "name": "closing_note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_message_at": {
+          "name": "last_message_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_message_by": {
+          "name": "last_message_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'member'"
+        }
+      },
+      "indexes": {
+        "tickets_number_idx": {
+          "name": "tickets_number_idx",
+          "columns": [
+            {
+              "expression": "number",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "tickets_status_idx": {
+          "name": "tickets_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "last_message_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "tickets_opened_by_idx": {
+          "name": "tickets_opened_by_idx",
+          "columns": [
+            {
+              "expression": "opened_by_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "tickets_opened_by_id_users_id_fk": {
+          "name": "tickets_opened_by_id_users_id_fk",
+          "tableFrom": "tickets",
+          "tableTo": "users",
+          "columnsFrom": [
+            "opened_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "tickets_assigned_to_id_users_id_fk": {
+          "name": "tickets_assigned_to_id_users_id_fk",
+          "tableFrom": "tickets",
+          "tableTo": "users",
+          "columnsFrom": [
+            "assigned_to_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "tickets_closed_by_id_users_id_fk": {
+          "name": "tickets_closed_by_id_users_id_fk",
+          "tableFrom": "tickets",
+          "tableTo": "users",
+          "columnsFrom": [
+            "closed_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "tickets_status_ck": {
+          "name": "tickets_status_ck",
+          "value": "\"tickets\".\"status\" IN ('open', 'closed')"
+        },
+        "tickets_closure_ck": {
+          "name": "tickets_closure_ck",
+          "value": "\"tickets\".\"closure_reason\" IS NULL\n          OR \"tickets\".\"closure_reason\"\n             IN ('resolved', 'rejected', 'stale', 'withdrawn')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.torrent_comments": {
+      "name": "torrent_comments",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_comments_torrent_idx": {
+          "name": "torrent_comments_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrent_comments_author_idx": {
+          "name": "torrent_comments_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_comments_torrent_id_torrents_id_fk": {
+          "name": "torrent_comments_torrent_id_torrents_id_fk",
+          "tableFrom": "torrent_comments",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "torrent_comments_author_id_users_id_fk": {
+          "name": "torrent_comments_author_id_users_id_fk",
+          "tableFrom": "torrent_comments",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_favorites": {
+      "name": "torrent_favorites",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_favorites_torrent_idx": {
+          "name": "torrent_favorites_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrent_favorites_user_created_idx": {
+          "name": "torrent_favorites_user_created_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_favorites_user_id_users_id_fk": {
+          "name": "torrent_favorites_user_id_users_id_fk",
+          "tableFrom": "torrent_favorites",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "torrent_favorites_torrent_id_torrents_id_fk": {
+          "name": "torrent_favorites_torrent_id_torrents_id_fk",
+          "tableFrom": "torrent_favorites",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "torrent_favorites_user_id_torrent_id_pk": {
+          "name": "torrent_favorites_user_id_torrent_id_pk",
+          "columns": [
+            "user_id",
+            "torrent_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_moderation_messages": {
+      "name": "torrent_moderation_messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_system": {
+          "name": "is_system",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "status_change": {
+          "name": "status_change",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_mod_messages_torrent_idx": {
+          "name": "torrent_mod_messages_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrent_mod_messages_author_idx": {
+          "name": "torrent_mod_messages_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_moderation_messages_torrent_id_torrents_id_fk": {
+          "name": "torrent_moderation_messages_torrent_id_torrents_id_fk",
+          "tableFrom": "torrent_moderation_messages",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "torrent_moderation_messages_author_id_users_id_fk": {
+          "name": "torrent_moderation_messages_author_id_users_id_fk",
+          "tableFrom": "torrent_moderation_messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_stats": {
+      "name": "torrent_stats",
+      "schema": "",
+      "columns": {
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "seeders": {
+          "name": "seeders",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "leechers": {
+          "name": "leechers",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "completed": {
+          "name": "completed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_stats_completed_idx": {
+          "name": "torrent_stats_completed_idx",
+          "columns": [
+            {
+              "expression": "\"completed\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrent_stats_seeders_idx": {
+          "name": "torrent_stats_seeders_idx",
+          "columns": [
+            {
+              "expression": "\"seeders\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_stats_info_hash_torrents_info_hash_fk": {
+          "name": "torrent_stats_info_hash_torrents_info_hash_fk",
+          "tableFrom": "torrent_stats",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "info_hash"
+          ],
+          "columnsTo": [
+            "info_hash"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_stats_history": {
+      "name": "torrent_stats_history",
+      "schema": "",
+      "columns": {
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "day": {
+          "name": "day",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "seeders": {
+          "name": "seeders",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "leechers": {
+          "name": "leechers",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "torrent_stats_history_info_hash_torrents_info_hash_fk": {
+          "name": "torrent_stats_history_info_hash_torrents_info_hash_fk",
+          "tableFrom": "torrent_stats_history",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "info_hash"
+          ],
+          "columnsTo": [
+            "info_hash"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "torrent_stats_history_info_hash_day_pk": {
+          "name": "torrent_stats_history_info_hash_day_pk",
+          "columns": [
+            "info_hash",
+            "day"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_tags": {
+      "name": "torrent_tags",
+      "schema": "",
+      "columns": {
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tag_id": {
+          "name": "tag_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_tags_tag_idx": {
+          "name": "torrent_tags_tag_idx",
+          "columns": [
+            {
+              "expression": "tag_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_tags_torrent_id_torrents_id_fk": {
+          "name": "torrent_tags_torrent_id_torrents_id_fk",
+          "tableFrom": "torrent_tags",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "torrent_tags_tag_id_tags_id_fk": {
+          "name": "torrent_tags_tag_id_tags_id_fk",
+          "tableFrom": "torrent_tags",
+          "tableTo": "tags",
+          "columnsFrom": [
+            "tag_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "torrent_tags_torrent_id_tag_id_pk": {
+          "name": "torrent_tags_torrent_id_tag_id_pk",
+          "columns": [
+            "torrent_id",
+            "tag_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrents": {
+      "name": "torrents",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size": {
+          "name": "size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "nfo": {
+          "name": "nfo",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "torrent_data": {
+          "name": "torrent_data",
+          "type": "bytea",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "uploader_id": {
+          "name": "uploader_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "imdb_id": {
+          "name": "imdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tmdb_id": {
+          "name": "tmdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tvdb_id": {
+          "name": "tvdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "igdb_id": {
+          "name": "igdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "openlibrary_id": {
+          "name": "openlibrary_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "season": {
+          "name": "season",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "episode": {
+          "name": "episode",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content_signature": {
+          "name": "content_signature",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "info_hash_v2": {
+          "name": "info_hash_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content_root_v2": {
+          "name": "content_root_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "download_multiplier": {
+          "name": "download_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 100
+        },
+        "upload_multiplier": {
+          "name": "upload_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 100
+        },
+        "multipliers_until": {
+          "name": "multipliers_until",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_sticky": {
+          "name": "is_sticky",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "superseded_by_id": {
+          "name": "superseded_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "superseded_at": {
+          "name": "superseded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "supersede_reason": {
+          "name": "supersede_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "federate_swarm": {
+          "name": "federate_swarm",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "moderation_status": {
+          "name": "moderation_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "moderated_by_id": {
+          "name": "moderated_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "moderated_at": {
+          "name": "moderated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "torrents_info_hash_idx": {
+          "name": "torrents_info_hash_idx",
+          "columns": [
+            {
+              "expression": "info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_updated_at_idx": {
+          "name": "torrents_updated_at_idx",
+          "columns": [
+            {
+              "expression": "updated_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_uploader_idx": {
+          "name": "torrents_uploader_idx",
+          "columns": [
+            {
+              "expression": "uploader_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_category_idx": {
+          "name": "torrents_category_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_imdb_idx": {
+          "name": "torrents_imdb_idx",
+          "columns": [
+            {
+              "expression": "imdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_tmdb_idx": {
+          "name": "torrents_tmdb_idx",
+          "columns": [
+            {
+              "expression": "tmdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_tmdb_season_idx": {
+          "name": "torrents_tmdb_season_idx",
+          "columns": [
+            {
+              "expression": "tmdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "season",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_grouped_idx": {
+          "name": "torrents_grouped_idx",
+          "columns": [
+            {
+              "expression": "coalesce(\"moderated_at\", \"created_at\") DESC",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"moderation_status\" = 'accepted' AND \"torrents\".\"is_active\" AND (\"torrents\".\"tmdb_id\" IS NOT NULL OR \"torrents\".\"igdb_id\" IS NOT NULL OR \"torrents\".\"openlibrary_id\" IS NOT NULL)",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_ungrouped_idx": {
+          "name": "torrents_ungrouped_idx",
+          "columns": [
+            {
+              "expression": "coalesce(\"moderated_at\", \"created_at\") DESC",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"moderation_status\" = 'accepted' AND \"torrents\".\"is_active\" AND \"torrents\".\"tmdb_id\" IS NULL AND \"torrents\".\"igdb_id\" IS NULL AND \"torrents\".\"openlibrary_id\" IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_tvdb_idx": {
+          "name": "torrents_tvdb_idx",
+          "columns": [
+            {
+              "expression": "tvdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_igdb_idx": {
+          "name": "torrents_igdb_idx",
+          "columns": [
+            {
+              "expression": "igdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_content_signature_idx": {
+          "name": "torrents_content_signature_idx",
+          "columns": [
+            {
+              "expression": "content_signature",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_superseded_by_idx": {
+          "name": "torrents_superseded_by_idx",
+          "columns": [
+            {
+              "expression": "superseded_by_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"superseded_by_id\" IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_content_root_v2_idx": {
+          "name": "torrents_content_root_v2_idx",
+          "columns": [
+            {
+              "expression": "content_root_v2",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_info_hash_v2_short_idx": {
+          "name": "torrents_info_hash_v2_short_idx",
+          "columns": [
+            {
+              "expression": "left(\"info_hash_v2\", 40)",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"info_hash_v2\" IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_openlibrary_idx": {
+          "name": "torrents_openlibrary_idx",
+          "columns": [
+            {
+              "expression": "openlibrary_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_created_at_idx": {
+          "name": "torrents_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_sticky_idx": {
+          "name": "torrents_sticky_idx",
+          "columns": [
+            {
+              "expression": "is_sticky",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"is_sticky\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_moderation_status_idx": {
+          "name": "torrents_moderation_status_idx",
+          "columns": [
+            {
+              "expression": "moderation_status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_name_trgm_idx": {
+          "name": "torrents_name_trgm_idx",
+          "columns": [
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "torrents_fts_name_idx": {
+          "name": "torrents_fts_name_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('simple', coalesce(translate(\"name\", '._', '  '), ''))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "torrents_fts_description_idx": {
+          "name": "torrents_fts_description_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('simple', coalesce(translate(\"description\", '._', '  '), ''))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "torrents_fts_nfo_idx": {
+          "name": "torrents_fts_nfo_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('simple', coalesce(translate(\"nfo\", '._', '  '), ''))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "torrents_mint_cursor_idx": {
+          "name": "torrents_mint_cursor_idx",
+          "columns": [
+            {
+              "expression": "coalesce(\"updated_at\", \"created_at\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrents_uploader_id_users_id_fk": {
+          "name": "torrents_uploader_id_users_id_fk",
+          "tableFrom": "torrents",
+          "tableTo": "users",
+          "columnsFrom": [
+            "uploader_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "torrents_category_id_categories_id_fk": {
+          "name": "torrents_category_id_categories_id_fk",
+          "tableFrom": "torrents",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "torrents_superseded_by_id_torrents_id_fk": {
+          "name": "torrents_superseded_by_id_torrents_id_fk",
+          "tableFrom": "torrents",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "superseded_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "torrents_moderated_by_id_users_id_fk": {
+          "name": "torrents_moderated_by_id_users_id_fk",
+          "tableFrom": "torrents",
+          "tableTo": "users",
+          "columnsFrom": [
+            "moderated_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "torrents_info_hash_unique": {
+          "name": "torrents_info_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "info_hash"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "torrents_multipliers_sane": {
+          "name": "torrents_multipliers_sane",
+          "value": "\"torrents\".\"download_multiplier\" between 0 and 200 and \"torrents\".\"upload_multiplier\" between 0 and 1000"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.trusted_devices": {
+      "name": "trusted_devices",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token_hash": {
+          "name": "token_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "label": {
+          "name": "label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_used_at": {
+          "name": "last_used_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "trusted_devices_user_idx": {
+          "name": "trusted_devices_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "trusted_devices_expires_idx": {
+          "name": "trusted_devices_expires_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "trusted_devices_user_id_users_id_fk": {
+          "name": "trusted_devices_user_id_users_id_fk",
+          "tableFrom": "trusted_devices",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "trusted_devices_token_hash_unique": {
+          "name": "trusted_devices_token_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "token_hash"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_request_comments": {
+      "name": "upload_request_comments",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "request_id": {
+          "name": "request_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "edited_at": {
+          "name": "edited_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_by_id": {
+          "name": "deleted_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "upload_request_comments_request_idx": {
+          "name": "upload_request_comments_request_idx",
+          "columns": [
+            {
+              "expression": "request_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "upload_request_comments_request_id_upload_requests_id_fk": {
+          "name": "upload_request_comments_request_id_upload_requests_id_fk",
+          "tableFrom": "upload_request_comments",
+          "tableTo": "upload_requests",
+          "columnsFrom": [
+            "request_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "upload_request_comments_author_id_users_id_fk": {
+          "name": "upload_request_comments_author_id_users_id_fk",
+          "tableFrom": "upload_request_comments",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "upload_request_comments_deleted_by_id_users_id_fk": {
+          "name": "upload_request_comments_deleted_by_id_users_id_fk",
+          "tableFrom": "upload_request_comments",
+          "tableTo": "users",
+          "columnsFrom": [
+            "deleted_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_request_fill_attempts": {
+      "name": "upload_request_fill_attempts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "request_id": {
+          "name": "request_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'proposed'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "rejected_at": {
+          "name": "rejected_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "upload_request_fill_attempts_torrent_idx": {
+          "name": "upload_request_fill_attempts_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_request_fill_attempts_user_idx": {
+          "name": "upload_request_fill_attempts_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_request_fill_attempts_request_user_idx": {
+          "name": "upload_request_fill_attempts_request_user_idx",
+          "columns": [
+            {
+              "expression": "request_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_request_fill_attempts_active_unique": {
+          "name": "upload_request_fill_attempts_active_unique",
+          "columns": [
+            {
+              "expression": "request_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "status = 'proposed'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "upload_request_fill_attempts_request_id_upload_requests_id_fk": {
+          "name": "upload_request_fill_attempts_request_id_upload_requests_id_fk",
+          "tableFrom": "upload_request_fill_attempts",
+          "tableTo": "upload_requests",
+          "columnsFrom": [
+            "request_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "upload_request_fill_attempts_user_id_users_id_fk": {
+          "name": "upload_request_fill_attempts_user_id_users_id_fk",
+          "tableFrom": "upload_request_fill_attempts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "upload_request_fill_attempts_torrent_id_torrents_id_fk": {
+          "name": "upload_request_fill_attempts_torrent_id_torrents_id_fk",
+          "tableFrom": "upload_request_fill_attempts",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_requests": {
+      "name": "upload_requests",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "requester_id": {
+          "name": "requester_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reward_points": {
+          "name": "reward_points",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'requested'"
+        },
+        "filled_by_id": {
+          "name": "filled_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filled_torrent_id": {
+          "name": "filled_torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filled_at": {
+          "name": "filled_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "validated_at": {
+          "name": "validated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cancelled_at": {
+          "name": "cancelled_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "federated_peer_id": {
+          "name": "federated_peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "federated_info_hash": {
+          "name": "federated_info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "federated_content_root_v2": {
+          "name": "federated_content_root_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "upload_requests_category_idx": {
+          "name": "upload_requests_category_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_requests_status_idx": {
+          "name": "upload_requests_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_requests_federated_info_hash_idx": {
+          "name": "upload_requests_federated_info_hash_idx",
+          "columns": [
+            {
+              "expression": "federated_info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_requests_requester_idx": {
+          "name": "upload_requests_requester_idx",
+          "columns": [
+            {
+              "expression": "requester_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_requests_filled_at_idx": {
+          "name": "upload_requests_filled_at_idx",
+          "columns": [
+            {
+              "expression": "filled_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "upload_requests_requester_id_users_id_fk": {
+          "name": "upload_requests_requester_id_users_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "users",
+          "columnsFrom": [
+            "requester_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "upload_requests_category_id_categories_id_fk": {
+          "name": "upload_requests_category_id_categories_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "upload_requests_filled_by_id_users_id_fk": {
+          "name": "upload_requests_filled_by_id_users_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "users",
+          "columnsFrom": [
+            "filled_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "upload_requests_filled_torrent_id_torrents_id_fk": {
+          "name": "upload_requests_filled_torrent_id_torrents_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "filled_torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "upload_requests_federated_peer_id_federation_peers_id_fk": {
+          "name": "upload_requests_federated_peer_id_federation_peers_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "federated_peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_rule_category_patterns": {
+      "name": "upload_rule_category_patterns",
+      "schema": "",
+      "columns": {
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "pattern": {
+          "name": "pattern",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "upload_rule_category_patterns_category_id_categories_id_fk": {
+          "name": "upload_rule_category_patterns_category_id_categories_id_fk",
+          "tableFrom": "upload_rule_category_patterns",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_rules": {
+      "name": "upload_rules",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "'singleton'"
+        },
+        "nfo_required": {
+          "name": "nfo_required",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "description_required": {
+          "name": "description_required",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "description_min_length": {
+          "name": "description_min_length",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "title_pattern_enforced": {
+          "name": "title_pattern_enforced",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "title_blocklist": {
+          "name": "title_blocklist",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tmdb_id_required": {
+          "name": "tmdb_id_required",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "max_torrent_size": {
+          "name": "max_torrent_size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "staff_bypass": {
+          "name": "staff_bypass",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.uploaded_fonts": {
+      "name": "uploaded_fonts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "family": {
+          "name": "family",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "storage_key": {
+          "name": "storage_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "bytes": {
+          "name": "bytes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sha256": {
+          "name": "sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "uploaded_by": {
+          "name": "uploaded_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "uploaded_fonts_role_idx": {
+          "name": "uploaded_fonts_role_idx",
+          "columns": [
+            {
+              "expression": "role",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "uploaded_fonts_uploaded_by_users_id_fk": {
+          "name": "uploaded_fonts_uploaded_by_users_id_fk",
+          "tableFrom": "uploaded_fonts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "uploaded_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "uploaded_fonts_sha256_unique": {
+          "name": "uploaded_fonts_sha256_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "sha256"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "uploaded_fonts_role_ck": {
+          "name": "uploaded_fonts_role_ck",
+          "value": "\"uploaded_fonts\".\"role\" IN ('sans', 'mono', 'display')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_follows": {
+      "name": "user_follows",
+      "schema": "",
+      "columns": {
+        "follower_id": {
+          "name": "follower_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "following_id": {
+          "name": "following_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "user_follows_following_idx": {
+          "name": "user_follows_following_idx",
+          "columns": [
+            {
+              "expression": "following_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_follows_follower_id_users_id_fk": {
+          "name": "user_follows_follower_id_users_id_fk",
+          "tableFrom": "user_follows",
+          "tableTo": "users",
+          "columnsFrom": [
+            "follower_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_follows_following_id_users_id_fk": {
+          "name": "user_follows_following_id_users_id_fk",
+          "tableFrom": "user_follows",
+          "tableTo": "users",
+          "columnsFrom": [
+            "following_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_follows_follower_id_following_id_pk": {
+          "name": "user_follows_follower_id_following_id_pk",
+          "columns": [
+            "follower_id",
+            "following_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_message_keys": {
+      "name": "user_message_keys",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "alg": {
+          "name": "alg",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'ECDH-P256'"
+        },
+        "device_label": {
+          "name": "device_label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "user_message_keys_user_id_users_id_fk": {
+          "name": "user_message_keys_user_id_users_id_fk",
+          "tableFrom": "user_message_keys",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_notification_channels": {
+      "name": "user_notification_channels",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "channel_type": {
+          "name": "channel_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "user_config": {
+          "name": "user_config",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "last_test_status": {
+          "name": "last_test_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_test_error": {
+          "name": "last_test_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_tested_at": {
+          "name": "last_tested_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "consecutive_failures": {
+          "name": "consecutive_failures",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "user_notification_channels_user_type_unique": {
+          "name": "user_notification_channels_user_type_unique",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "channel_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_notification_channels_user_id_users_id_fk": {
+          "name": "user_notification_channels_user_id_users_id_fk",
+          "tableFrom": "user_notification_channels",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_notification_routing": {
+      "name": "user_notification_routing",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "channel_type": {
+          "name": "channel_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "user_notification_routing_pk": {
+          "name": "user_notification_routing_pk",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "user_notification_routing_user_idx": {
+          "name": "user_notification_routing_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_notification_routing_user_id_users_id_fk": {
+          "name": "user_notification_routing_user_id_users_id_fk",
+          "tableFrom": "user_notification_routing",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_roles": {
+      "name": "user_roles",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role_id": {
+          "name": "role_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "assigned_at": {
+          "name": "assigned_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "assigned_manually": {
+          "name": "assigned_manually",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        }
+      },
+      "indexes": {
+        "user_roles_role_idx": {
+          "name": "user_roles_role_idx",
+          "columns": [
+            {
+              "expression": "role_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_roles_user_id_users_id_fk": {
+          "name": "user_roles_user_id_users_id_fk",
+          "tableFrom": "user_roles",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_roles_role_id_roles_id_fk": {
+          "name": "user_roles_role_id_roles_id_fk",
+          "tableFrom": "user_roles",
+          "tableTo": "roles",
+          "columnsFrom": [
+            "role_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_roles_user_id_role_id_pk": {
+          "name": "user_roles_user_id_role_id_pk",
+          "columns": [
+            "user_id",
+            "role_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_signing_keys": {
+      "name": "user_signing_keys",
+      "schema": "",
+      "columns": {
+        "did": {
+          "name": "did",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "private_key_enc": {
+          "name": "private_key_enc",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "revoked_at": {
+          "name": "revoked_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "succeeded_by": {
+          "name": "succeeded_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "user_signing_keys_current": {
+          "name": "user_signing_keys_current",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "revoked_at IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "user_signing_keys_user_idx": {
+          "name": "user_signing_keys_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_signing_keys_user_id_users_id_fk": {
+          "name": "user_signing_keys_user_id_users_id_fk",
+          "tableFrom": "user_signing_keys",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "auth_salt": {
+          "name": "auth_salt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "auth_verifier": {
+          "name": "auth_verifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "passkey": {
+          "name": "passkey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rss_key": {
+          "name": "rss_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "api_key": {
+          "name": "api_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_admin": {
+          "name": "is_admin",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_moderator": {
+          "name": "is_moderator",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_owner": {
+          "name": "is_owner",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "session_epoch": {
+          "name": "session_epoch",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "is_banned": {
+          "name": "is_banned",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "banned_by_id": {
+          "name": "banned_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "banned_by_role": {
+          "name": "banned_by_role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "banned_until": {
+          "name": "banned_until",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ban_reason": {
+          "name": "ban_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_ip": {
+          "name": "last_ip",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "uploaded": {
+          "name": "uploaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "bonus_uploaded": {
+          "name": "bonus_uploaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "downloaded": {
+          "name": "downloaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "invites_remaining": {
+          "name": "invites_remaining",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "bonus_points": {
+          "name": "bonus_points",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "panic_password_hash": {
+          "name": "panic_password_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bio": {
+          "name": "bio",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "show_last_seen": {
+          "name": "show_last_seen",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "show_adult_content": {
+          "name": "show_adult_content",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "messaging_read_receipts": {
+          "name": "messaging_read_receipts",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "anonymous_uploads": {
+          "name": "anonymous_uploads",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "hide_download_history": {
+          "name": "hide_download_history",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "restrict_comments": {
+          "name": "restrict_comments",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "share_reputation_federated": {
+          "name": "share_reputation_federated",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "theme": {
+          "name": "theme",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "language": {
+          "name": "language",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'en'"
+        },
+        "totp_secret": {
+          "name": "totp_secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "totp_enabled": {
+          "name": "totp_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "trust_devices_enabled": {
+          "name": "trust_devices_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_seen": {
+          "name": "last_seen",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "users_owner_unique": {
+          "name": "users_owner_unique",
+          "columns": [
+            {
+              "expression": "is_owner",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"users\".\"is_owner\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "users_username_lower_unique": {
+          "name": "users_username_lower_unique",
+          "columns": [
+            {
+              "expression": "lower(\"username\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "users_username_unique": {
+          "name": "users_username_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "username"
+          ]
+        },
+        "users_passkey_unique": {
+          "name": "users_passkey_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "passkey"
+          ]
+        },
+        "users_rss_key_unique": {
+          "name": "users_rss_key_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "rss_key"
+          ]
+        },
+        "users_api_key_unique": {
+          "name": "users_api_key_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "api_key"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.webauthn_credentials": {
+      "name": "webauthn_credentials",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "credential_id": {
+          "name": "credential_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "counter": {
+          "name": "counter",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "transports": {
+          "name": "transports",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_used_at": {
+          "name": "last_used_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "webauthn_credentials_user_idx": {
+          "name": "webauthn_credentials_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "webauthn_credentials_user_id_users_id_fk": {
+          "name": "webauthn_credentials_user_id_users_id_fk",
+          "tableFrom": "webauthn_credentials",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "webauthn_credentials_credential_id_unique": {
+          "name": "webauthn_credentials_credential_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "credential_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
\ No newline at end of file
diff --git a/packages/db/src/migrations/meta/0076_snapshot.json b/packages/db/src/migrations/meta/0076_snapshot.json
new file mode 100644
index 00000000..93bb4229
--- /dev/null
+++ b/packages/db/src/migrations/meta/0076_snapshot.json
@@ -0,0 +1,10829 @@
+{
+  "id": "20ee16c5-6a11-4a51-a32c-47215d700d8c",
+  "prevId": "bcee98a6-619a-407e-a65f-2fe8a5767013",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.announce_log": {
+      "name": "announce_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "event": {
+          "name": "event",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ip_hash": {
+          "name": "ip_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "port": {
+          "name": "port",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "uploaded": {
+          "name": "uploaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "downloaded": {
+          "name": "downloaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "left": {
+          "name": "left",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "announce_log_info_hash_idx": {
+          "name": "announce_log_info_hash_idx",
+          "columns": [
+            {
+              "expression": "info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "announce_log_created_at_idx": {
+          "name": "announce_log_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.anticheat_flags": {
+      "name": "anticheat_flags",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "severity": {
+          "name": "severity",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'medium'"
+        },
+        "details": {
+          "name": "details",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ip": {
+          "name": "ip",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "reviewed_at": {
+          "name": "reviewed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reviewed_by_id": {
+          "name": "reviewed_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "review_verdict": {
+          "name": "review_verdict",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "review_note": {
+          "name": "review_note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "anticheat_flags_torrent_idx": {
+          "name": "anticheat_flags_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "anticheat_flags_user_idx": {
+          "name": "anticheat_flags_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "anticheat_flags_unreviewed_idx": {
+          "name": "anticheat_flags_unreviewed_idx",
+          "columns": [
+            {
+              "expression": "reviewed_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "anticheat_flags_kind_idx": {
+          "name": "anticheat_flags_kind_idx",
+          "columns": [
+            {
+              "expression": "kind",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "anticheat_flags_no_leecher_open_unique": {
+          "name": "anticheat_flags_no_leecher_open_unique",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "kind = 'no_leecher' AND reviewed_at IS NULL AND torrent_id IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "anticheat_flags_user_id_users_id_fk": {
+          "name": "anticheat_flags_user_id_users_id_fk",
+          "tableFrom": "anticheat_flags",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "anticheat_flags_torrent_id_torrents_id_fk": {
+          "name": "anticheat_flags_torrent_id_torrents_id_fk",
+          "tableFrom": "anticheat_flags",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "anticheat_flags_reviewed_by_id_users_id_fk": {
+          "name": "anticheat_flags_reviewed_by_id_users_id_fk",
+          "tableFrom": "anticheat_flags",
+          "tableTo": "users",
+          "columnsFrom": [
+            "reviewed_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.audit_log": {
+      "name": "audit_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "actor_name": {
+          "name": "actor_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_role": {
+          "name": "actor_role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "method": {
+          "name": "method",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_type": {
+          "name": "target_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_label": {
+          "name": "target_label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "changes": {
+          "name": "changes",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status_code": {
+          "name": "status_code",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "actor_ip_hash": {
+          "name": "actor_ip_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "audit_log_created_idx": {
+          "name": "audit_log_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "audit_log_actor_idx": {
+          "name": "audit_log_actor_idx",
+          "columns": [
+            {
+              "expression": "actor_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "audit_log_target_idx": {
+          "name": "audit_log_target_idx",
+          "columns": [
+            {
+              "expression": "target_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "target_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "audit_log_action_idx": {
+          "name": "audit_log_action_idx",
+          "columns": [
+            {
+              "expression": "action",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "audit_log_actor_id_users_id_fk": {
+          "name": "audit_log_actor_id_users_id_fk",
+          "tableFrom": "audit_log",
+          "tableTo": "users",
+          "columnsFrom": [
+            "actor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.banned_ips": {
+      "name": "banned_ips",
+      "schema": "",
+      "columns": {
+        "ip": {
+          "name": "ip",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_age_tiers": {
+      "name": "bonus_age_tiers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "min_age_days": {
+          "name": "min_age_days",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "multiplier": {
+          "name": "multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "bonus_age_tiers_threshold_idx": {
+          "name": "bonus_age_tiers_threshold_idx",
+          "columns": [
+            {
+              "expression": "min_age_days",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_age_tiers_enabled_idx": {
+          "name": "bonus_age_tiers_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_events": {
+      "name": "bonus_events",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "long_description": {
+          "name": "long_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "download_multiplier": {
+          "name": "download_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "upload_multiplier": {
+          "name": "upload_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "starts_at": {
+          "name": "starts_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ends_at": {
+          "name": "ends_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'manual'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "created_by_id": {
+          "name": "created_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "bonus_events_window_idx": {
+          "name": "bonus_events_window_idx",
+          "columns": [
+            {
+              "expression": "starts_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "ends_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_events_enabled_idx": {
+          "name": "bonus_events_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "bonus_events_created_by_id_users_id_fk": {
+          "name": "bonus_events_created_by_id_users_id_fk",
+          "tableFrom": "bonus_events",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_grants": {
+      "name": "bonus_grants",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "amount": {
+          "name": "amount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "bonus_grants_user_idx": {
+          "name": "bonus_grants_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_grants_source_user_torrent_idx": {
+          "name": "bonus_grants_source_user_torrent_idx",
+          "columns": [
+            {
+              "expression": "source",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_grants_first_seeder_unique_idx": {
+          "name": "bonus_grants_first_seeder_unique_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "source = 'first_seeder' AND torrent_id IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "bonus_grants_user_id_users_id_fk": {
+          "name": "bonus_grants_user_id_users_id_fk",
+          "tableFrom": "bonus_grants",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "bonus_grants_torrent_id_torrents_id_fk": {
+          "name": "bonus_grants_torrent_id_torrents_id_fk",
+          "tableFrom": "bonus_grants",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_rules": {
+      "name": "bonus_rules",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "config": {
+          "name": "config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "bonus_rules_kind_idx": {
+          "name": "bonus_rules_kind_idx",
+          "columns": [
+            {
+              "expression": "kind",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "bonus_rules_kind_unique": {
+          "name": "bonus_rules_kind_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "kind"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.bonus_seed_count_tiers": {
+      "name": "bonus_seed_count_tiers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "max_seeders": {
+          "name": "max_seeders",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "multiplier": {
+          "name": "multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "bonus_seed_count_tiers_threshold_idx": {
+          "name": "bonus_seed_count_tiers_threshold_idx",
+          "columns": [
+            {
+              "expression": "max_seeders",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bonus_seed_count_tiers_enabled_idx": {
+          "name": "bonus_seed_count_tiers_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.catalog_records": {
+      "name": "catalog_records",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'torrent'"
+        },
+        "origin": {
+          "name": "origin",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'local'"
+        },
+        "hops": {
+          "name": "hops",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "via": {
+          "name": "via",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content_hash": {
+          "name": "content_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "supersedes": {
+          "name": "supersedes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "superseded_at": {
+          "name": "superseded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "catalog_records_info_hash_idx": {
+          "name": "catalog_records_info_hash_idx",
+          "columns": [
+            {
+              "expression": "info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "catalog_records_created_idx": {
+          "name": "catalog_records_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "catalog_records_relayable_idx": {
+          "name": "catalog_records_relayable_idx",
+          "columns": [
+            {
+              "expression": "origin",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "hops",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "catalog_records_live_idx": {
+          "name": "catalog_records_live_idx",
+          "columns": [
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "superseded_at IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "catalog_records_current_idx": {
+          "name": "catalog_records_current_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "superseded_at IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "catalog_records_origin_ck": {
+          "name": "catalog_records_origin_ck",
+          "value": "\"catalog_records\".\"origin\" IN ('local', 'ingested')"
+        },
+        "catalog_records_kind_ck": {
+          "name": "catalog_records_kind_ck",
+          "value": "\"catalog_records\".\"kind\" IN ('torrent', 'tombstone', 'identity', 'revocation')"
+        },
+        "catalog_records_hops_ck": {
+          "name": "catalog_records_hops_ck",
+          "value": "\"catalog_records\".\"hops\" BETWEEN 0 AND 2"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.categories": {
+      "name": "categories",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "parent_id": {
+          "name": "parent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "newznab_id": {
+          "name": "newznab_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_adult": {
+          "name": "is_adult",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "categories_parent_idx": {
+          "name": "categories_parent_idx",
+          "columns": [
+            {
+              "expression": "parent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "categories_slug_unique": {
+          "name": "categories_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.conversation_participants": {
+      "name": "conversation_participants",
+      "schema": "",
+      "columns": {
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "joined_at": {
+          "name": "joined_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_read_at": {
+          "name": "last_read_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "unread_count": {
+          "name": "unread_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "muted_until": {
+          "name": "muted_until",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "archived_at": {
+          "name": "archived_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "state": {
+          "name": "state",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'active'"
+        }
+      },
+      "indexes": {
+        "conversation_participants_inbox_idx": {
+          "name": "conversation_participants_inbox_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "state",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "archived_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "conversation_participants_conversation_id_conversations_id_fk": {
+          "name": "conversation_participants_conversation_id_conversations_id_fk",
+          "tableFrom": "conversation_participants",
+          "tableTo": "conversations",
+          "columnsFrom": [
+            "conversation_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "conversation_participants_user_id_users_id_fk": {
+          "name": "conversation_participants_user_id_users_id_fk",
+          "tableFrom": "conversation_participants",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "conversation_participants_conversation_id_user_id_pk": {
+          "name": "conversation_participants_conversation_id_user_id_pk",
+          "columns": [
+            "conversation_id",
+            "user_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "conversation_participants_state_ck": {
+          "name": "conversation_participants_state_ck",
+          "value": "\"conversation_participants\".\"state\" IN ('active', 'pending', 'blocked')"
+        },
+        "conversation_participants_unread_ck": {
+          "name": "conversation_participants_unread_ck",
+          "value": "\"conversation_participants\".\"unread_count\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.conversations": {
+      "name": "conversations",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "pinned_message_id": {
+          "name": "pinned_message_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pinned_at": {
+          "name": "pinned_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pinned_by_id": {
+          "name": "pinned_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "encrypted": {
+          "name": "encrypted",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_by_id": {
+          "name": "created_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_message_at": {
+          "name": "last_message_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "conversations_slug_idx": {
+          "name": "conversations_slug_idx",
+          "columns": [
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "conversations_last_message_idx": {
+          "name": "conversations_last_message_idx",
+          "columns": [
+            {
+              "expression": "last_message_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "conversations_created_by_id_users_id_fk": {
+          "name": "conversations_created_by_id_users_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "conversations_kind_ck": {
+          "name": "conversations_kind_ck",
+          "value": "\"conversations\".\"kind\" IN ('dm', 'room')"
+        },
+        "conversations_room_slug_ck": {
+          "name": "conversations_room_slug_ck",
+          "value": "(\"conversations\".\"kind\" = 'room') = (\"conversations\".\"slug\" IS NOT NULL)"
+        },
+        "conversations_room_plain_ck": {
+          "name": "conversations_room_plain_ck",
+          "value": "NOT (\"conversations\".\"kind\" = 'room' AND \"conversations\".\"encrypted\")"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.federated_follows": {
+      "name": "federated_follows",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "local_user_id": {
+          "name": "local_user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "remote_username": {
+          "name": "remote_username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "federated_follows_unique": {
+          "name": "federated_follows_unique",
+          "columns": [
+            {
+              "expression": "local_user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "remote_username",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "federated_follows_target_idx": {
+          "name": "federated_follows_target_idx",
+          "columns": [
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "remote_username",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "federated_follows_local_user_id_users_id_fk": {
+          "name": "federated_follows_local_user_id_users_id_fk",
+          "tableFrom": "federated_follows",
+          "tableTo": "users",
+          "columnsFrom": [
+            "local_user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "federated_follows_peer_id_federation_peers_id_fk": {
+          "name": "federated_follows_peer_id_federation_peers_id_fk",
+          "tableFrom": "federated_follows",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federated_identities": {
+      "name": "federated_identities",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "local_user_id": {
+          "name": "local_user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "remote_username": {
+          "name": "remote_username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "method": {
+          "name": "method",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'bio'"
+        },
+        "subject_did": {
+          "name": "subject_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "evidence": {
+          "name": "evidence",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "verify_code": {
+          "name": "verify_code",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "verified_at": {
+          "name": "verified_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "federated_identities_unique": {
+          "name": "federated_identities_unique",
+          "columns": [
+            {
+              "expression": "local_user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "remote_username",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "federated_identities_local_user_id_users_id_fk": {
+          "name": "federated_identities_local_user_id_users_id_fk",
+          "tableFrom": "federated_identities",
+          "tableTo": "users",
+          "columnsFrom": [
+            "local_user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "federated_identities_peer_id_federation_peers_id_fk": {
+          "name": "federated_identities_peer_id_federation_peers_id_fk",
+          "tableFrom": "federated_identities",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federation_config": {
+      "name": "federation_config",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "'singleton'"
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "relay_enabled": {
+          "name": "relay_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "discoverable": {
+          "name": "discoverable",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "instance_name": {
+          "name": "instance_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "public_url": {
+          "name": "public_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "instance_id": {
+          "name": "instance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "private_key_enc": {
+          "name": "private_key_enc",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "default_scopes": {
+          "name": "default_scopes",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"catalog\":false,\"social\":false,\"accounts\":false,\"swarm\":false}'::jsonb"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federation_credit_grants": {
+      "name": "federation_credit_grants",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "subject_did": {
+          "name": "subject_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "local_user_id": {
+          "name": "local_user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bytes": {
+          "name": "bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "period_start": {
+          "name": "period_start",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "period_end": {
+          "name": "period_end",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "federation_credit_grants_user_idx": {
+          "name": "federation_credit_grants_user_idx",
+          "columns": [
+            {
+              "expression": "local_user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "federation_credit_grants_period_idx": {
+          "name": "federation_credit_grants_period_idx",
+          "columns": [
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "subject_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "period_end",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "federation_credit_grants_created_idx": {
+          "name": "federation_credit_grants_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "federation_credit_grants_peer_id_federation_peers_id_fk": {
+          "name": "federation_credit_grants_peer_id_federation_peers_id_fk",
+          "tableFrom": "federation_credit_grants",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "federation_credit_grants_local_user_id_users_id_fk": {
+          "name": "federation_credit_grants_local_user_id_users_id_fk",
+          "tableFrom": "federation_credit_grants",
+          "tableTo": "users",
+          "columnsFrom": [
+            "local_user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federation_peers": {
+      "name": "federation_peers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "base_url": {
+          "name": "base_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "instance_id": {
+          "name": "instance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending_out'"
+        },
+        "shares_with_them": {
+          "name": "shares_with_them",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"catalog\":false,\"social\":false,\"accounts\":false,\"swarm\":false}'::jsonb"
+        },
+        "accepts_from_them": {
+          "name": "accepts_from_them",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"catalog\":false,\"social\":false,\"accounts\":false,\"swarm\":false}'::jsonb"
+        },
+        "last_handshake_at": {
+          "name": "last_handshake_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_seen_at": {
+          "name": "last_seen_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "protocol_version": {
+          "name": "protocol_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "federation_peers_status_idx": {
+          "name": "federation_peers_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "federation_peers_instance_id_unique": {
+          "name": "federation_peers_instance_id_unique",
+          "columns": [
+            {
+              "expression": "instance_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "instance_id IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "federation_peers_created_by_users_id_fk": {
+          "name": "federation_peers_created_by_users_id_fk",
+          "tableFrom": "federation_peers",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "federation_peers_base_url_unique": {
+          "name": "federation_peers_base_url_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "base_url"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.federation_sync_state": {
+      "name": "federation_sync_state",
+      "schema": "",
+      "columns": {
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "resource": {
+          "name": "resource",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cursor": {
+          "name": "cursor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_run_at": {
+          "name": "last_run_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_status": {
+          "name": "last_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "items_synced": {
+          "name": "items_synced",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "federation_sync_state_peer_id_federation_peers_id_fk": {
+          "name": "federation_sync_state_peer_id_federation_peers_id_fk",
+          "tableFrom": "federation_sync_state",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "federation_sync_state_peer_id_resource_pk": {
+          "name": "federation_sync_state_peer_id_resource_pk",
+          "columns": [
+            "peer_id",
+            "resource"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.forum_categories": {
+      "name": "forum_categories",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "color": {
+          "name": "color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "order": {
+          "name": "order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.forum_posts": {
+      "name": "forum_posts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "topic_id": {
+          "name": "topic_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "forum_posts_topic_idx": {
+          "name": "forum_posts_topic_idx",
+          "columns": [
+            {
+              "expression": "topic_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "forum_posts_author_idx": {
+          "name": "forum_posts_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "forum_posts_topic_id_forum_topics_id_fk": {
+          "name": "forum_posts_topic_id_forum_topics_id_fk",
+          "tableFrom": "forum_posts",
+          "tableTo": "forum_topics",
+          "columnsFrom": [
+            "topic_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "forum_posts_author_id_users_id_fk": {
+          "name": "forum_posts_author_id_users_id_fk",
+          "tableFrom": "forum_posts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.forum_topics": {
+      "name": "forum_topics",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_pinned": {
+          "name": "is_pinned",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_locked": {
+          "name": "is_locked",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "forum_topics_category_idx": {
+          "name": "forum_topics_category_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "forum_topics_author_idx": {
+          "name": "forum_topics_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "forum_topics_category_id_forum_categories_id_fk": {
+          "name": "forum_topics_category_id_forum_categories_id_fk",
+          "tableFrom": "forum_topics",
+          "tableTo": "forum_categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "forum_topics_author_id_users_id_fk": {
+          "name": "forum_topics_author_id_users_id_fk",
+          "tableFrom": "forum_topics",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.freeleech_pool_config": {
+      "name": "freeleech_pool_config",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "points_target": {
+          "name": "points_target",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "freeleech_duration_days": {
+          "name": "freeleech_duration_days",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "contribution_min": {
+          "name": "contribution_min",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "max_per_user_bp": {
+          "name": "max_per_user_bp",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "preset_amounts": {
+          "name": "preset_amounts",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "event_title_template": {
+          "name": "event_title_template",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event_description_template": {
+          "name": "event_description_template",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event_long_description_template": {
+          "name": "event_long_description_template",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "freeleech_pool_config_singleton": {
+          "name": "freeleech_pool_config_singleton",
+          "columns": [
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "id = 1",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.freeleech_pool_contributions": {
+      "name": "freeleech_pool_contributions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "cycle_id": {
+          "name": "cycle_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "amount": {
+          "name": "amount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "freeleech_pool_contributions_user_idx": {
+          "name": "freeleech_pool_contributions_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "freeleech_pool_contributions_cycle_idx": {
+          "name": "freeleech_pool_contributions_cycle_idx",
+          "columns": [
+            {
+              "expression": "cycle_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "freeleech_pool_contributions_cycle_user_idx": {
+          "name": "freeleech_pool_contributions_cycle_user_idx",
+          "columns": [
+            {
+              "expression": "cycle_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "freeleech_pool_contributions_cycle_id_freeleech_pool_cycles_id_fk": {
+          "name": "freeleech_pool_contributions_cycle_id_freeleech_pool_cycles_id_fk",
+          "tableFrom": "freeleech_pool_contributions",
+          "tableTo": "freeleech_pool_cycles",
+          "columnsFrom": [
+            "cycle_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "freeleech_pool_contributions_user_id_users_id_fk": {
+          "name": "freeleech_pool_contributions_user_id_users_id_fk",
+          "tableFrom": "freeleech_pool_contributions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.freeleech_pool_cycles": {
+      "name": "freeleech_pool_cycles",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'filling'"
+        },
+        "target_snapshot": {
+          "name": "target_snapshot",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "duration_days_snapshot": {
+          "name": "duration_days_snapshot",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total_contributed": {
+          "name": "total_contributed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ends_at": {
+          "name": "ends_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "triggered_event_id": {
+          "name": "triggered_event_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_title": {
+          "name": "paused_event_title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_description": {
+          "name": "paused_event_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_long_description": {
+          "name": "paused_event_long_description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_download_multiplier": {
+          "name": "paused_event_download_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_upload_multiplier": {
+          "name": "paused_event_upload_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_remaining_ms": {
+          "name": "paused_event_remaining_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "paused_event_created_by_id": {
+          "name": "paused_event_created_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "waiting_on_event_id": {
+          "name": "waiting_on_event_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "closed_at": {
+          "name": "closed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "freeleech_pool_cycles_status_idx": {
+          "name": "freeleech_pool_cycles_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "freeleech_pool_cycles_open_unique": {
+          "name": "freeleech_pool_cycles_open_unique",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "status IN ('filling', 'full_queued', 'active')",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "freeleech_pool_cycles_triggered_event_id_bonus_events_id_fk": {
+          "name": "freeleech_pool_cycles_triggered_event_id_bonus_events_id_fk",
+          "tableFrom": "freeleech_pool_cycles",
+          "tableTo": "bonus_events",
+          "columnsFrom": [
+            "triggered_event_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "freeleech_pool_cycles_paused_event_created_by_id_users_id_fk": {
+          "name": "freeleech_pool_cycles_paused_event_created_by_id_users_id_fk",
+          "tableFrom": "freeleech_pool_cycles",
+          "tableTo": "users",
+          "columnsFrom": [
+            "paused_event_created_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "freeleech_pool_cycles_waiting_on_event_id_bonus_events_id_fk": {
+          "name": "freeleech_pool_cycles_waiting_on_event_id_bonus_events_id_fk",
+          "tableFrom": "freeleech_pool_cycles",
+          "tableTo": "bonus_events",
+          "columnsFrom": [
+            "waiting_on_event_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.freeleech_pool_windows": {
+      "name": "freeleech_pool_windows",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "starts_at": {
+          "name": "starts_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ends_at": {
+          "name": "ends_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "weekday_start": {
+          "name": "weekday_start",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "weekday_end": {
+          "name": "weekday_end",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "minute_start": {
+          "name": "minute_start",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "minute_end": {
+          "name": "minute_end",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "monthly_days": {
+          "name": "monthly_days",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year_month_start": {
+          "name": "year_month_start",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year_day_start": {
+          "name": "year_day_start",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year_month_end": {
+          "name": "year_month_end",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year_day_end": {
+          "name": "year_day_end",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "label": {
+          "name": "label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "freeleech_pool_windows_kind_idx": {
+          "name": "freeleech_pool_windows_kind_idx",
+          "columns": [
+            {
+              "expression": "kind",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "freeleech_pool_windows_oneoff_idx": {
+          "name": "freeleech_pool_windows_oneoff_idx",
+          "columns": [
+            {
+              "expression": "starts_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "ends_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.hnr_tracking": {
+      "name": "hnr_tracking",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "downloaded_at": {
+          "name": "downloaded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "seed_time": {
+          "name": "seed_time",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "required_seed_time": {
+          "name": "required_seed_time",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 86400
+        },
+        "is_hnr": {
+          "name": "is_hnr",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_exempt": {
+          "name": "is_exempt",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "uploaded": {
+          "name": "uploaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "downloaded": {
+          "name": "downloaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "hnr_downloaded_at_idx": {
+          "name": "hnr_downloaded_at_idx",
+          "columns": [
+            {
+              "expression": "downloaded_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_completed_at_idx": {
+          "name": "hnr_completed_at_idx",
+          "columns": [
+            {
+              "expression": "completed_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_torrent_idx": {
+          "name": "hnr_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_status_idx": {
+          "name": "hnr_status_idx",
+          "columns": [
+            {
+              "expression": "is_hnr",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"hnr_tracking\".\"is_hnr\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_user_torrent_idx": {
+          "name": "hnr_user_torrent_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "hnr_user_is_hnr_idx": {
+          "name": "hnr_user_is_hnr_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "is_hnr",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "hnr_tracking_user_id_users_id_fk": {
+          "name": "hnr_tracking_user_id_users_id_fk",
+          "tableFrom": "hnr_tracking",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "hnr_tracking_torrent_id_torrents_id_fk": {
+          "name": "hnr_tracking_torrent_id_torrents_id_fk",
+          "tableFrom": "hnr_tracking",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.invitations": {
+      "name": "invitations",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "code": {
+          "name": "code",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "used_by": {
+          "name": "used_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "used_at": {
+          "name": "used_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "invitations_created_by_idx": {
+          "name": "invitations_created_by_idx",
+          "columns": [
+            {
+              "expression": "created_by",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "invitations_used_by_idx": {
+          "name": "invitations_used_by_idx",
+          "columns": [
+            {
+              "expression": "used_by",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"invitations\".\"used_by\" IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "invitations_created_by_users_id_fk": {
+          "name": "invitations_created_by_users_id_fk",
+          "tableFrom": "invitations",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "invitations_used_by_users_id_fk": {
+          "name": "invitations_used_by_users_id_fk",
+          "tableFrom": "invitations",
+          "tableTo": "users",
+          "columnsFrom": [
+            "used_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "invitations_code_unique": {
+          "name": "invitations_code_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "code"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.login_events": {
+      "name": "login_events",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "method": {
+          "name": "method",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "outcome": {
+          "name": "outcome",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip_hash": {
+          "name": "ip_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "login_events_user_idx": {
+          "name": "login_events_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "login_events_created_idx": {
+          "name": "login_events_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "login_events_user_id_users_id_fk": {
+          "name": "login_events_user_id_users_id_fk",
+          "tableFrom": "login_events",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.message_reactions": {
+      "name": "message_reactions",
+      "schema": "",
+      "columns": {
+        "message_id": {
+          "name": "message_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "message_reactions_user_idx": {
+          "name": "message_reactions_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "message_reactions_message_id_messages_id_fk": {
+          "name": "message_reactions_message_id_messages_id_fk",
+          "tableFrom": "message_reactions",
+          "tableTo": "messages",
+          "columnsFrom": [
+            "message_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "message_reactions_user_id_users_id_fk": {
+          "name": "message_reactions_user_id_users_id_fk",
+          "tableFrom": "message_reactions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "message_reactions_message_id_user_id_key_pk": {
+          "name": "message_reactions_message_id_user_id_key_pk",
+          "columns": [
+            "message_id",
+            "user_id",
+            "key"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "message_reactions_key_ck": {
+          "name": "message_reactions_key_ck",
+          "value": "\"message_reactions\".\"key\" IN ('up', 'heart', 'haha', 'wow', 'thanks', 'done')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.message_read_log": {
+      "name": "message_read_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "reader_id": {
+          "name": "reader_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reader_name": {
+          "name": "reader_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "message_id": {
+          "name": "message_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "report_id": {
+          "name": "report_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "disclosed": {
+          "name": "disclosed",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "message_read_log_created_idx": {
+          "name": "message_read_log_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "message_read_log_reader_idx": {
+          "name": "message_read_log_reader_idx",
+          "columns": [
+            {
+              "expression": "reader_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "message_read_log_message_idx": {
+          "name": "message_read_log_message_idx",
+          "columns": [
+            {
+              "expression": "message_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "message_read_log_reader_id_users_id_fk": {
+          "name": "message_read_log_reader_id_users_id_fk",
+          "tableFrom": "message_read_log",
+          "tableTo": "users",
+          "columnsFrom": [
+            "reader_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.messages": {
+      "name": "messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reply_to_id": {
+          "name": "reply_to_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cipher": {
+          "name": "cipher",
+          "type": "bytea",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "iv": {
+          "name": "iv",
+          "type": "bytea",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_system": {
+          "name": "is_system",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "edited_at": {
+          "name": "edited_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_by_id": {
+          "name": "deleted_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "messages_reply_to_idx": {
+          "name": "messages_reply_to_idx",
+          "columns": [
+            {
+              "expression": "reply_to_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "messages_author_idx": {
+          "name": "messages_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "messages_conversation_idx": {
+          "name": "messages_conversation_idx",
+          "columns": [
+            {
+              "expression": "conversation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "messages_conversation_id_conversations_id_fk": {
+          "name": "messages_conversation_id_conversations_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "conversations",
+          "columnsFrom": [
+            "conversation_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "messages_author_id_users_id_fk": {
+          "name": "messages_author_id_users_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "messages_reply_to_id_messages_id_fk": {
+          "name": "messages_reply_to_id_messages_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "messages",
+          "columnsFrom": [
+            "reply_to_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "messages_deleted_by_id_users_id_fk": {
+          "name": "messages_deleted_by_id_users_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "deleted_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "messages_payload_ck": {
+          "name": "messages_payload_ck",
+          "value": "\"messages\".\"deleted_at\" IS NOT NULL OR ((\"messages\".\"body\" IS NOT NULL) <> (\"messages\".\"cipher\" IS NOT NULL))"
+        },
+        "messages_cipher_iv_ck": {
+          "name": "messages_cipher_iv_ck",
+          "value": "(\"messages\".\"cipher\" IS NULL) = (\"messages\".\"iv\" IS NULL)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.messaging_blocks": {
+      "name": "messaging_blocks",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "blocked_id": {
+          "name": "blocked_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "messaging_blocks_blocked_idx": {
+          "name": "messaging_blocks_blocked_idx",
+          "columns": [
+            {
+              "expression": "blocked_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "messaging_blocks_user_id_users_id_fk": {
+          "name": "messaging_blocks_user_id_users_id_fk",
+          "tableFrom": "messaging_blocks",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "messaging_blocks_blocked_id_users_id_fk": {
+          "name": "messaging_blocks_blocked_id_users_id_fk",
+          "tableFrom": "messaging_blocks",
+          "tableTo": "users",
+          "columnsFrom": [
+            "blocked_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "messaging_blocks_user_id_blocked_id_pk": {
+          "name": "messaging_blocks_user_id_blocked_id_pk",
+          "columns": [
+            "user_id",
+            "blocked_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "messaging_blocks_self_ck": {
+          "name": "messaging_blocks_self_ck",
+          "value": "\"messaging_blocks\".\"user_id\" <> \"messaging_blocks\".\"blocked_id\""
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.messaging_broadcasts": {
+      "name": "messaging_broadcasts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "created_by_id": {
+          "name": "created_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "audience": {
+          "name": "audience",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total": {
+          "name": "total",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "sent": {
+          "name": "sent",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "finished_at": {
+          "name": "finished_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error": {
+          "name": "error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "messaging_broadcasts_created_idx": {
+          "name": "messaging_broadcasts_created_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "messaging_broadcasts_created_by_id_users_id_fk": {
+          "name": "messaging_broadcasts_created_by_id_users_id_fk",
+          "tableFrom": "messaging_broadcasts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notification_channels": {
+      "name": "notification_channels",
+      "schema": "",
+      "columns": {
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "server_config": {
+          "name": "server_config",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "last_test_status": {
+          "name": "last_test_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_test_error": {
+          "name": "last_test_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_tested_at": {
+          "name": "last_tested_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_by": {
+          "name": "updated_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "notification_channels_updated_by_users_id_fk": {
+          "name": "notification_channels_updated_by_users_id_fk",
+          "tableFrom": "notification_channels",
+          "tableTo": "users",
+          "columnsFrom": [
+            "updated_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.notifications": {
+      "name": "notifications",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "payload": {
+          "name": "payload",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "link": {
+          "name": "link",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "read_at": {
+          "name": "read_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "notifications_user_created_idx": {
+          "name": "notifications_user_created_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "notifications_user_unread_idx": {
+          "name": "notifications_user_unread_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "read_at IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "notifications_user_id_users_id_fk": {
+          "name": "notifications_user_id_users_id_fk",
+          "tableFrom": "notifications",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.panic_state": {
+      "name": "panic_state",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "'singleton'"
+        },
+        "is_encrypted": {
+          "name": "is_encrypted",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "encrypted_at": {
+          "name": "encrypted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "encryption_salt": {
+          "name": "encryption_salt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "encryption_iv": {
+          "name": "encryption_iv",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "kdf_version": {
+          "name": "kdf_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "panic_password_hash": {
+          "name": "panic_password_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "phase": {
+          "name": "phase",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'idle'"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "panic_state_phase_ck": {
+          "name": "panic_state_phase_ck",
+          "value": "\"panic_state\".\"phase\" IN ('idle', 'encrypting', 'encrypted', 'restoring')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.presentation_templates": {
+      "name": "presentation_templates",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'universal'"
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "visibility": {
+          "name": "visibility",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'private'"
+        },
+        "is_default": {
+          "name": "is_default",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "presentation_templates_owner_idx": {
+          "name": "presentation_templates_owner_idx",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "presentation_templates_site_idx": {
+          "name": "presentation_templates_site_idx",
+          "columns": [
+            {
+              "expression": "category",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"presentation_templates\".\"visibility\" = 'site'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "presentation_templates_default_unique": {
+          "name": "presentation_templates_default_unique",
+          "columns": [
+            {
+              "expression": "owner_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"presentation_templates\".\"is_default\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "presentation_templates_owner_id_users_id_fk": {
+          "name": "presentation_templates_owner_id_users_id_fk",
+          "tableFrom": "presentation_templates",
+          "tableTo": "users",
+          "columnsFrom": [
+            "owner_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "presentation_templates_created_by_users_id_fk": {
+          "name": "presentation_templates_created_by_users_id_fk",
+          "tableFrom": "presentation_templates",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "presentation_templates_scope_ck": {
+          "name": "presentation_templates_scope_ck",
+          "value": "(\"presentation_templates\".\"visibility\" = 'private' AND \"presentation_templates\".\"owner_id\" IS NOT NULL)\n          OR (\"presentation_templates\".\"visibility\" = 'site' AND \"presentation_templates\".\"owner_id\" IS NULL AND \"presentation_templates\".\"is_default\" = false)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.record_sources": {
+      "name": "record_sources",
+      "schema": "",
+      "columns": {
+        "record_id": {
+          "name": "record_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'torrent'"
+        },
+        "first_seen_at": {
+          "name": "first_seen_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "record_sources_record_idx": {
+          "name": "record_sources_record_idx",
+          "columns": [
+            {
+              "expression": "record_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "record_sources_peer_id_federation_peers_id_fk": {
+          "name": "record_sources_peer_id_federation_peers_id_fk",
+          "tableFrom": "record_sources",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "record_sources_peer_id_record_id_pk": {
+          "name": "record_sources_peer_id_record_id_pk",
+          "columns": [
+            "peer_id",
+            "record_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.recovery_codes": {
+      "name": "recovery_codes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "code_hash": {
+          "name": "code_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "used_at": {
+          "name": "used_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "recovery_codes_user_idx": {
+          "name": "recovery_codes_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "recovery_codes_user_id_users_id_fk": {
+          "name": "recovery_codes_user_id_users_id_fk",
+          "tableFrom": "recovery_codes",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.remote_category_map": {
+      "name": "remote_category_map",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "remote_slug": {
+          "name": "remote_slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "local_category_id": {
+          "name": "local_category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "remote_category_map_slug_idx": {
+          "name": "remote_category_map_slug_idx",
+          "columns": [
+            {
+              "expression": "remote_slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_category_map_category_idx": {
+          "name": "remote_category_map_category_idx",
+          "columns": [
+            {
+              "expression": "local_category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "remote_category_map_local_category_id_categories_id_fk": {
+          "name": "remote_category_map_local_category_id_categories_id_fk",
+          "tableFrom": "remote_category_map",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "local_category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "remote_category_map_created_by_users_id_fk": {
+          "name": "remote_category_map_created_by_users_id_fk",
+          "tableFrom": "remote_category_map",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.remote_identity_links": {
+      "name": "remote_identity_links",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject_did": {
+          "name": "subject_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "alias_did": {
+          "name": "alias_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "evidence": {
+          "name": "evidence",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "record_id": {
+          "name": "record_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "remote_identity_links_unique": {
+          "name": "remote_identity_links_unique",
+          "columns": [
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "subject_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "alias_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_identity_links_subject_idx": {
+          "name": "remote_identity_links_subject_idx",
+          "columns": [
+            {
+              "expression": "subject_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_identity_links_alias_idx": {
+          "name": "remote_identity_links_alias_idx",
+          "columns": [
+            {
+              "expression": "alias_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "remote_identity_links_peer_id_federation_peers_id_fk": {
+          "name": "remote_identity_links_peer_id_federation_peers_id_fk",
+          "tableFrom": "remote_identity_links",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.remote_masks": {
+      "name": "remote_masks",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "remote_masks_scope_value_idx": {
+          "name": "remote_masks_scope_value_idx",
+          "columns": [
+            {
+              "expression": "scope",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "value",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_masks_value_idx": {
+          "name": "remote_masks_value_idx",
+          "columns": [
+            {
+              "expression": "value",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "remote_masks_created_by_users_id_fk": {
+          "name": "remote_masks_created_by_users_id_fk",
+          "tableFrom": "remote_masks",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.remote_torrents": {
+      "name": "remote_torrents",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "peer_id": {
+          "name": "peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "remote_id": {
+          "name": "remote_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content_signature": {
+          "name": "content_signature",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "info_hash_v2": {
+          "name": "info_hash_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content_root_v2": {
+          "name": "content_root_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size": {
+          "name": "size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category_slug": {
+          "name": "category_slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category_type": {
+          "name": "category_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_adult": {
+          "name": "is_adult",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "tags": {
+          "name": "tags",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "imdb_id": {
+          "name": "imdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tmdb_id": {
+          "name": "tmdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tvdb_id": {
+          "name": "tvdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "igdb_id": {
+          "name": "igdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "openlibrary_id": {
+          "name": "openlibrary_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "season": {
+          "name": "season",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "episode": {
+          "name": "episode",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "seeders": {
+          "name": "seeders",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "leechers": {
+          "name": "leechers",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "completed": {
+          "name": "completed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "record_id": {
+          "name": "record_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "author_did": {
+          "name": "author_did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "verified": {
+          "name": "verified",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "uploader_name": {
+          "name": "uploader_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote_created_at": {
+          "name": "remote_created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote_detail_url": {
+          "name": "remote_detail_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "remote_download_url": {
+          "name": "remote_download_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "fetched_at": {
+          "name": "fetched_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "remote_torrents_peer_remote_unique": {
+          "name": "remote_torrents_peer_remote_unique",
+          "columns": [
+            {
+              "expression": "peer_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "remote_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_info_hash_idx": {
+          "name": "remote_torrents_info_hash_idx",
+          "columns": [
+            {
+              "expression": "info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_content_root_v2_idx": {
+          "name": "remote_torrents_content_root_v2_idx",
+          "columns": [
+            {
+              "expression": "content_root_v2",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_content_sig_idx": {
+          "name": "remote_torrents_content_sig_idx",
+          "columns": [
+            {
+              "expression": "content_signature",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_imdb_idx": {
+          "name": "remote_torrents_imdb_idx",
+          "columns": [
+            {
+              "expression": "imdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_tmdb_idx": {
+          "name": "remote_torrents_tmdb_idx",
+          "columns": [
+            {
+              "expression": "tmdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_igdb_idx": {
+          "name": "remote_torrents_igdb_idx",
+          "columns": [
+            {
+              "expression": "igdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_openlibrary_idx": {
+          "name": "remote_torrents_openlibrary_idx",
+          "columns": [
+            {
+              "expression": "openlibrary_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_record_idx": {
+          "name": "remote_torrents_record_idx",
+          "columns": [
+            {
+              "expression": "record_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_author_idx": {
+          "name": "remote_torrents_author_idx",
+          "columns": [
+            {
+              "expression": "author_did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "remote_torrents_name_idx": {
+          "name": "remote_torrents_name_idx",
+          "columns": [
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "remote_torrents_peer_id_federation_peers_id_fk": {
+          "name": "remote_torrents_peer_id_federation_peers_id_fk",
+          "tableFrom": "remote_torrents",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.reports": {
+      "name": "reports",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "reporter_id": {
+          "name": "reporter_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_type": {
+          "name": "target_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_id": {
+          "name": "target_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "details": {
+          "name": "details",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "withdrawn_at": {
+          "name": "withdrawn_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resolved_by": {
+          "name": "resolved_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resolved_at": {
+          "name": "resolved_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resolution": {
+          "name": "resolution",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "reports_reporter_idx": {
+          "name": "reports_reporter_idx",
+          "columns": [
+            {
+              "expression": "reporter_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reports_target_idx": {
+          "name": "reports_target_idx",
+          "columns": [
+            {
+              "expression": "target_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "target_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reports_status_idx": {
+          "name": "reports_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reports_reporter_id_users_id_fk": {
+          "name": "reports_reporter_id_users_id_fk",
+          "tableFrom": "reports",
+          "tableTo": "users",
+          "columnsFrom": [
+            "reporter_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reports_resolved_by_users_id_fk": {
+          "name": "reports_resolved_by_users_id_fk",
+          "tableFrom": "reports",
+          "tableTo": "users",
+          "columnsFrom": [
+            "resolved_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.revoked_identities": {
+      "name": "revoked_identities",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "did": {
+          "name": "did",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "issuer": {
+          "name": "issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "succeeded_by": {
+          "name": "succeeded_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "record_id": {
+          "name": "record_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "revoked_at": {
+          "name": "revoked_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "revoked_identities_unique": {
+          "name": "revoked_identities_unique",
+          "columns": [
+            {
+              "expression": "issuer",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "revoked_identities_did_idx": {
+          "name": "revoked_identities_did_idx",
+          "columns": [
+            {
+              "expression": "did",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.roles": {
+      "name": "roles",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "color": {
+          "name": "color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'#6b7280'"
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "show_as_badge": {
+          "name": "show_as_badge",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "priority": {
+          "name": "priority",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "assignment_mode": {
+          "name": "assignment_mode",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'manual'"
+        },
+        "rules": {
+          "name": "rules",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "can_upload_without_moderation": {
+          "name": "can_upload_without_moderation",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "roles_name_unique": {
+          "name": "roles_name_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "name"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.room_message_reactions": {
+      "name": "room_message_reactions",
+      "schema": "",
+      "columns": {
+        "message_id": {
+          "name": "message_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "message_created_at": {
+          "name": "message_created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "room_message_reactions_user_idx": {
+          "name": "room_message_reactions_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "room_message_reactions_message_idx": {
+          "name": "room_message_reactions_message_idx",
+          "columns": [
+            {
+              "expression": "message_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "message_created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "room_message_reactions_user_id_users_id_fk": {
+          "name": "room_message_reactions_user_id_users_id_fk",
+          "tableFrom": "room_message_reactions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "room_message_reactions_message_id_message_created_at_user_id_key_pk": {
+          "name": "room_message_reactions_message_id_message_created_at_user_id_key_pk",
+          "columns": [
+            "message_id",
+            "message_created_at",
+            "user_id",
+            "key"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "room_message_reactions_key_ck": {
+          "name": "room_message_reactions_key_ck",
+          "value": "\"room_message_reactions\".\"key\" IN ('up', 'heart', 'haha', 'wow', 'thanks', 'done')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.room_messages": {
+      "name": "room_messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_system": {
+          "name": "is_system",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "reply_to_id": {
+          "name": "reply_to_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "edited_at": {
+          "name": "edited_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_by_id": {
+          "name": "deleted_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "room_messages_conversation_idx": {
+          "name": "room_messages_conversation_idx",
+          "columns": [
+            {
+              "expression": "conversation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "room_messages_conversation_id_conversations_id_fk": {
+          "name": "room_messages_conversation_id_conversations_id_fk",
+          "tableFrom": "room_messages",
+          "tableTo": "conversations",
+          "columnsFrom": [
+            "conversation_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "room_messages_author_id_users_id_fk": {
+          "name": "room_messages_author_id_users_id_fk",
+          "tableFrom": "room_messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "room_messages_deleted_by_id_users_id_fk": {
+          "name": "room_messages_deleted_by_id_users_id_fk",
+          "tableFrom": "room_messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "deleted_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "room_messages_id_created_at_pk": {
+          "name": "room_messages_id_created_at_pk",
+          "columns": [
+            "id",
+            "created_at"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.room_mutes": {
+      "name": "room_mutes",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "until": {
+          "name": "until",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "by_id": {
+          "name": "by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "room_mutes_until_idx": {
+          "name": "room_mutes_until_idx",
+          "columns": [
+            {
+              "expression": "until",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "room_mutes_user_id_users_id_fk": {
+          "name": "room_mutes_user_id_users_id_fk",
+          "tableFrom": "room_mutes",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "room_mutes_by_id_users_id_fk": {
+          "name": "room_mutes_by_id_users_id_fk",
+          "tableFrom": "room_mutes",
+          "tableTo": "users",
+          "columnsFrom": [
+            "by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.saved_searches": {
+      "name": "saved_searches",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "label": {
+          "name": "label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "query": {
+          "name": "query",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tsquery": {
+          "name": "tsquery",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tags": {
+          "name": "tags",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "imdb_id": {
+          "name": "imdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tmdb_id": {
+          "name": "tmdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tvdb_id": {
+          "name": "tvdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "notify": {
+          "name": "notify",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_matched_at": {
+          "name": "last_matched_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "match_count": {
+          "name": "match_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "seen_count": {
+          "name": "seen_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "tag_groups": {
+          "name": "tag_groups",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "season": {
+          "name": "season",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "episode": {
+          "name": "episode",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year": {
+          "name": "year",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "uploader_id": {
+          "name": "uploader_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "saved_searches_category_idx": {
+          "name": "saved_searches_category_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "saved_searches_user_idx": {
+          "name": "saved_searches_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "saved_searches_notify_idx": {
+          "name": "saved_searches_notify_idx",
+          "columns": [
+            {
+              "expression": "notify",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"saved_searches\".\"notify\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "saved_searches_user_id_users_id_fk": {
+          "name": "saved_searches_user_id_users_id_fk",
+          "tableFrom": "saved_searches",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "saved_searches_category_id_categories_id_fk": {
+          "name": "saved_searches_category_id_categories_id_fk",
+          "tableFrom": "saved_searches",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "saved_searches_uploader_id_users_id_fk": {
+          "name": "saved_searches_uploader_id_users_id_fk",
+          "tableFrom": "saved_searches",
+          "tableTo": "users",
+          "columnsFrom": [
+            "uploader_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.search_misses": {
+      "name": "search_misses",
+      "schema": "",
+      "columns": {
+        "query": {
+          "name": "query",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "count": {
+          "name": "count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "first_at": {
+          "name": "first_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_at": {
+          "name": "last_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "search_misses_count_idx": {
+          "name": "search_misses_count_idx",
+          "columns": [
+            {
+              "expression": "count",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            },
+            {
+              "expression": "last_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.settings": {
+      "name": "settings",
+      "schema": "",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.shop_items": {
+      "name": "shop_items",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "payload": {
+          "name": "payload",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cost": {
+          "name": "cost",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "stock": {
+          "name": "stock",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "shop_items_enabled_idx": {
+          "name": "shop_items_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.shop_purchases": {
+      "name": "shop_purchases",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "item_id": {
+          "name": "item_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "item_name_snapshot": {
+          "name": "item_name_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "item_type_snapshot": {
+          "name": "item_type_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cost_paid": {
+          "name": "cost_paid",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "shop_purchases_user_idx": {
+          "name": "shop_purchases_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "shop_purchases_item_idx": {
+          "name": "shop_purchases_item_idx",
+          "columns": [
+            {
+              "expression": "item_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "shop_purchases_user_id_users_id_fk": {
+          "name": "shop_purchases_user_id_users_id_fk",
+          "tableFrom": "shop_purchases",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "shop_purchases_item_id_shop_items_id_fk": {
+          "name": "shop_purchases_item_id_shop_items_id_fk",
+          "tableFrom": "shop_purchases",
+          "tableTo": "shop_items",
+          "columnsFrom": [
+            "item_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.site_stats": {
+      "name": "site_stats",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "users_count": {
+          "name": "users_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrents_count": {
+          "name": "torrents_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "peers_count": {
+          "name": "peers_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "seeders_count": {
+          "name": "seeders_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "redis_memory_usage": {
+          "name": "redis_memory_usage",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "db_size": {
+          "name": "db_size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total_uploaded_bytes": {
+          "name": "total_uploaded_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "site_stats_created_at_idx": {
+          "name": "site_stats_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tags": {
+      "name": "tags",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "color": {
+          "name": "color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'#6b7280'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "tags_fts_name_idx": {
+          "name": "tags_fts_name_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('simple', coalesce(translate(\"name\", '._', '  '), ''))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "tags_name_unique": {
+          "name": "tags_name_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "name"
+          ]
+        },
+        "tags_slug_unique": {
+          "name": "tags_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.themes": {
+      "name": "themes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "base": {
+          "name": "base",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'dark'"
+        },
+        "tokens": {
+          "name": "tokens",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "custom_css": {
+          "name": "custom_css",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "visibility": {
+          "name": "visibility",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'site'"
+        },
+        "required_roles": {
+          "name": "required_roles",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "themes_enabled_idx": {
+          "name": "themes_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "position",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "themes_created_by_users_id_fk": {
+          "name": "themes_created_by_users_id_fk",
+          "tableFrom": "themes",
+          "tableTo": "users",
+          "columnsFrom": [
+            "created_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "themes_slug_unique": {
+          "name": "themes_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "slug"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "themes_visibility_ck": {
+          "name": "themes_visibility_ck",
+          "value": "(\"themes\".\"visibility\" = 'site' AND \"themes\".\"required_roles\" IS NULL)\n          OR (\"themes\".\"visibility\" = 'roles' AND jsonb_array_length(\"themes\".\"required_roles\") > 0)"
+        },
+        "themes_base_ck": {
+          "name": "themes_base_ck",
+          "value": "\"themes\".\"base\" IN ('light', 'dark')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.ticket_messages": {
+      "name": "ticket_messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "ticket_id": {
+          "name": "ticket_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "author_name": {
+          "name": "author_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "from_staff": {
+          "name": "from_staff",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "ticket_messages_author_idx": {
+          "name": "ticket_messages_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "ticket_messages_ticket_idx": {
+          "name": "ticket_messages_ticket_idx",
+          "columns": [
+            {
+              "expression": "ticket_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "ticket_messages_ticket_id_tickets_id_fk": {
+          "name": "ticket_messages_ticket_id_tickets_id_fk",
+          "tableFrom": "ticket_messages",
+          "tableTo": "tickets",
+          "columnsFrom": [
+            "ticket_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "ticket_messages_author_id_users_id_fk": {
+          "name": "ticket_messages_author_id_users_id_fk",
+          "tableFrom": "ticket_messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tickets": {
+      "name": "tickets",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "number": {
+          "name": "number",
+          "type": "serial",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "opened_by_id": {
+          "name": "opened_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "opened_by_name": {
+          "name": "opened_by_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'other'"
+        },
+        "subject": {
+          "name": "subject",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'open'"
+        },
+        "closure_reason": {
+          "name": "closure_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "idle_notice_at": {
+          "name": "idle_notice_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "assigned_to_id": {
+          "name": "assigned_to_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "assigned_to_name": {
+          "name": "assigned_to_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "assigned_at": {
+          "name": "assigned_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "closed_by_id": {
+          "name": "closed_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "closed_by_name": {
+          "name": "closed_by_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "closed_at": {
+          "name": "closed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "closing_note": {
+          "name": "closing_note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_message_at": {
+          "name": "last_message_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_message_by": {
+          "name": "last_message_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'member'"
+        }
+      },
+      "indexes": {
+        "tickets_number_idx": {
+          "name": "tickets_number_idx",
+          "columns": [
+            {
+              "expression": "number",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "tickets_status_idx": {
+          "name": "tickets_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "last_message_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "tickets_opened_by_idx": {
+          "name": "tickets_opened_by_idx",
+          "columns": [
+            {
+              "expression": "opened_by_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "tickets_opened_by_id_users_id_fk": {
+          "name": "tickets_opened_by_id_users_id_fk",
+          "tableFrom": "tickets",
+          "tableTo": "users",
+          "columnsFrom": [
+            "opened_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "tickets_assigned_to_id_users_id_fk": {
+          "name": "tickets_assigned_to_id_users_id_fk",
+          "tableFrom": "tickets",
+          "tableTo": "users",
+          "columnsFrom": [
+            "assigned_to_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "tickets_closed_by_id_users_id_fk": {
+          "name": "tickets_closed_by_id_users_id_fk",
+          "tableFrom": "tickets",
+          "tableTo": "users",
+          "columnsFrom": [
+            "closed_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "tickets_status_ck": {
+          "name": "tickets_status_ck",
+          "value": "\"tickets\".\"status\" IN ('open', 'closed')"
+        },
+        "tickets_closure_ck": {
+          "name": "tickets_closure_ck",
+          "value": "\"tickets\".\"closure_reason\" IS NULL\n          OR \"tickets\".\"closure_reason\"\n             IN ('resolved', 'rejected', 'stale', 'withdrawn')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.torrent_comments": {
+      "name": "torrent_comments",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_comments_torrent_idx": {
+          "name": "torrent_comments_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrent_comments_author_idx": {
+          "name": "torrent_comments_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_comments_torrent_id_torrents_id_fk": {
+          "name": "torrent_comments_torrent_id_torrents_id_fk",
+          "tableFrom": "torrent_comments",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "torrent_comments_author_id_users_id_fk": {
+          "name": "torrent_comments_author_id_users_id_fk",
+          "tableFrom": "torrent_comments",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_favorites": {
+      "name": "torrent_favorites",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_favorites_torrent_idx": {
+          "name": "torrent_favorites_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrent_favorites_user_created_idx": {
+          "name": "torrent_favorites_user_created_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_favorites_user_id_users_id_fk": {
+          "name": "torrent_favorites_user_id_users_id_fk",
+          "tableFrom": "torrent_favorites",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "torrent_favorites_torrent_id_torrents_id_fk": {
+          "name": "torrent_favorites_torrent_id_torrents_id_fk",
+          "tableFrom": "torrent_favorites",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "torrent_favorites_user_id_torrent_id_pk": {
+          "name": "torrent_favorites_user_id_torrent_id_pk",
+          "columns": [
+            "user_id",
+            "torrent_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_moderation_messages": {
+      "name": "torrent_moderation_messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_system": {
+          "name": "is_system",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "status_change": {
+          "name": "status_change",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_mod_messages_torrent_idx": {
+          "name": "torrent_mod_messages_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrent_mod_messages_author_idx": {
+          "name": "torrent_mod_messages_author_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_moderation_messages_torrent_id_torrents_id_fk": {
+          "name": "torrent_moderation_messages_torrent_id_torrents_id_fk",
+          "tableFrom": "torrent_moderation_messages",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "torrent_moderation_messages_author_id_users_id_fk": {
+          "name": "torrent_moderation_messages_author_id_users_id_fk",
+          "tableFrom": "torrent_moderation_messages",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_stats": {
+      "name": "torrent_stats",
+      "schema": "",
+      "columns": {
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "seeders": {
+          "name": "seeders",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "leechers": {
+          "name": "leechers",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "completed": {
+          "name": "completed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_stats_completed_idx": {
+          "name": "torrent_stats_completed_idx",
+          "columns": [
+            {
+              "expression": "\"completed\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrent_stats_seeders_idx": {
+          "name": "torrent_stats_seeders_idx",
+          "columns": [
+            {
+              "expression": "\"seeders\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_stats_info_hash_torrents_info_hash_fk": {
+          "name": "torrent_stats_info_hash_torrents_info_hash_fk",
+          "tableFrom": "torrent_stats",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "info_hash"
+          ],
+          "columnsTo": [
+            "info_hash"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_stats_history": {
+      "name": "torrent_stats_history",
+      "schema": "",
+      "columns": {
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "day": {
+          "name": "day",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "seeders": {
+          "name": "seeders",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "leechers": {
+          "name": "leechers",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "torrent_stats_history_info_hash_torrents_info_hash_fk": {
+          "name": "torrent_stats_history_info_hash_torrents_info_hash_fk",
+          "tableFrom": "torrent_stats_history",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "info_hash"
+          ],
+          "columnsTo": [
+            "info_hash"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "torrent_stats_history_info_hash_day_pk": {
+          "name": "torrent_stats_history_info_hash_day_pk",
+          "columns": [
+            "info_hash",
+            "day"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrent_tags": {
+      "name": "torrent_tags",
+      "schema": "",
+      "columns": {
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tag_id": {
+          "name": "tag_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "torrent_tags_tag_idx": {
+          "name": "torrent_tags_tag_idx",
+          "columns": [
+            {
+              "expression": "tag_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrent_tags_torrent_id_torrents_id_fk": {
+          "name": "torrent_tags_torrent_id_torrents_id_fk",
+          "tableFrom": "torrent_tags",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "torrent_tags_tag_id_tags_id_fk": {
+          "name": "torrent_tags_tag_id_tags_id_fk",
+          "tableFrom": "torrent_tags",
+          "tableTo": "tags",
+          "columnsFrom": [
+            "tag_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "torrent_tags_torrent_id_tag_id_pk": {
+          "name": "torrent_tags_torrent_id_tag_id_pk",
+          "columns": [
+            "torrent_id",
+            "tag_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.torrents": {
+      "name": "torrents",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "info_hash": {
+          "name": "info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size": {
+          "name": "size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "nfo": {
+          "name": "nfo",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "torrent_data": {
+          "name": "torrent_data",
+          "type": "bytea",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "uploader_id": {
+          "name": "uploader_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "imdb_id": {
+          "name": "imdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tmdb_id": {
+          "name": "tmdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tvdb_id": {
+          "name": "tvdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "igdb_id": {
+          "name": "igdb_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "openlibrary_id": {
+          "name": "openlibrary_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "season": {
+          "name": "season",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "episode": {
+          "name": "episode",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content_signature": {
+          "name": "content_signature",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "info_hash_v2": {
+          "name": "info_hash_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content_root_v2": {
+          "name": "content_root_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "download_multiplier": {
+          "name": "download_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 100
+        },
+        "upload_multiplier": {
+          "name": "upload_multiplier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 100
+        },
+        "multipliers_until": {
+          "name": "multipliers_until",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_sticky": {
+          "name": "is_sticky",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "superseded_by_id": {
+          "name": "superseded_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "superseded_at": {
+          "name": "superseded_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "supersede_reason": {
+          "name": "supersede_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "federate_swarm": {
+          "name": "federate_swarm",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "moderation_status": {
+          "name": "moderation_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "moderated_by_id": {
+          "name": "moderated_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "moderated_at": {
+          "name": "moderated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "torrents_info_hash_idx": {
+          "name": "torrents_info_hash_idx",
+          "columns": [
+            {
+              "expression": "info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_updated_at_idx": {
+          "name": "torrents_updated_at_idx",
+          "columns": [
+            {
+              "expression": "updated_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_uploader_idx": {
+          "name": "torrents_uploader_idx",
+          "columns": [
+            {
+              "expression": "uploader_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_category_idx": {
+          "name": "torrents_category_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_imdb_idx": {
+          "name": "torrents_imdb_idx",
+          "columns": [
+            {
+              "expression": "imdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_tmdb_idx": {
+          "name": "torrents_tmdb_idx",
+          "columns": [
+            {
+              "expression": "tmdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_tmdb_season_idx": {
+          "name": "torrents_tmdb_season_idx",
+          "columns": [
+            {
+              "expression": "tmdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "season",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_grouped_idx": {
+          "name": "torrents_grouped_idx",
+          "columns": [
+            {
+              "expression": "coalesce(\"moderated_at\", \"created_at\") DESC",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"moderation_status\" = 'accepted' AND \"torrents\".\"is_active\" AND (\"torrents\".\"tmdb_id\" IS NOT NULL OR \"torrents\".\"igdb_id\" IS NOT NULL OR \"torrents\".\"openlibrary_id\" IS NOT NULL)",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_ungrouped_idx": {
+          "name": "torrents_ungrouped_idx",
+          "columns": [
+            {
+              "expression": "coalesce(\"moderated_at\", \"created_at\") DESC",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"moderation_status\" = 'accepted' AND \"torrents\".\"is_active\" AND \"torrents\".\"tmdb_id\" IS NULL AND \"torrents\".\"igdb_id\" IS NULL AND \"torrents\".\"openlibrary_id\" IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_tvdb_idx": {
+          "name": "torrents_tvdb_idx",
+          "columns": [
+            {
+              "expression": "tvdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_igdb_idx": {
+          "name": "torrents_igdb_idx",
+          "columns": [
+            {
+              "expression": "igdb_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_content_signature_idx": {
+          "name": "torrents_content_signature_idx",
+          "columns": [
+            {
+              "expression": "content_signature",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_superseded_by_idx": {
+          "name": "torrents_superseded_by_idx",
+          "columns": [
+            {
+              "expression": "superseded_by_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"superseded_by_id\" IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_content_root_v2_idx": {
+          "name": "torrents_content_root_v2_idx",
+          "columns": [
+            {
+              "expression": "content_root_v2",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_info_hash_v2_short_idx": {
+          "name": "torrents_info_hash_v2_short_idx",
+          "columns": [
+            {
+              "expression": "left(\"info_hash_v2\", 40)",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"info_hash_v2\" IS NOT NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_openlibrary_idx": {
+          "name": "torrents_openlibrary_idx",
+          "columns": [
+            {
+              "expression": "openlibrary_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_created_at_idx": {
+          "name": "torrents_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_sticky_idx": {
+          "name": "torrents_sticky_idx",
+          "columns": [
+            {
+              "expression": "is_sticky",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"torrents\".\"is_sticky\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_moderation_status_idx": {
+          "name": "torrents_moderation_status_idx",
+          "columns": [
+            {
+              "expression": "moderation_status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "torrents_name_trgm_idx": {
+          "name": "torrents_name_trgm_idx",
+          "columns": [
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "torrents_fts_name_idx": {
+          "name": "torrents_fts_name_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('simple', coalesce(translate(\"name\", '._', '  '), ''))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "torrents_fts_description_idx": {
+          "name": "torrents_fts_description_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('simple', coalesce(translate(\"description\", '._', '  '), ''))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "torrents_fts_nfo_idx": {
+          "name": "torrents_fts_nfo_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('simple', coalesce(translate(\"nfo\", '._', '  '), ''))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "torrents_mint_cursor_idx": {
+          "name": "torrents_mint_cursor_idx",
+          "columns": [
+            {
+              "expression": "coalesce(\"updated_at\", \"created_at\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "torrents_uploader_id_users_id_fk": {
+          "name": "torrents_uploader_id_users_id_fk",
+          "tableFrom": "torrents",
+          "tableTo": "users",
+          "columnsFrom": [
+            "uploader_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "torrents_category_id_categories_id_fk": {
+          "name": "torrents_category_id_categories_id_fk",
+          "tableFrom": "torrents",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "torrents_superseded_by_id_torrents_id_fk": {
+          "name": "torrents_superseded_by_id_torrents_id_fk",
+          "tableFrom": "torrents",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "superseded_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "torrents_moderated_by_id_users_id_fk": {
+          "name": "torrents_moderated_by_id_users_id_fk",
+          "tableFrom": "torrents",
+          "tableTo": "users",
+          "columnsFrom": [
+            "moderated_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "torrents_info_hash_unique": {
+          "name": "torrents_info_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "info_hash"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "torrents_multipliers_sane": {
+          "name": "torrents_multipliers_sane",
+          "value": "\"torrents\".\"download_multiplier\" between 0 and 200 and \"torrents\".\"upload_multiplier\" between 0 and 1000"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.trusted_devices": {
+      "name": "trusted_devices",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token_hash": {
+          "name": "token_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "label": {
+          "name": "label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_used_at": {
+          "name": "last_used_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "trusted_devices_user_idx": {
+          "name": "trusted_devices_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "trusted_devices_expires_idx": {
+          "name": "trusted_devices_expires_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "trusted_devices_user_id_users_id_fk": {
+          "name": "trusted_devices_user_id_users_id_fk",
+          "tableFrom": "trusted_devices",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "trusted_devices_token_hash_unique": {
+          "name": "trusted_devices_token_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "token_hash"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_request_comments": {
+      "name": "upload_request_comments",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "request_id": {
+          "name": "request_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "edited_at": {
+          "name": "edited_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_by_id": {
+          "name": "deleted_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "upload_request_comments_request_idx": {
+          "name": "upload_request_comments_request_idx",
+          "columns": [
+            {
+              "expression": "request_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "upload_request_comments_request_id_upload_requests_id_fk": {
+          "name": "upload_request_comments_request_id_upload_requests_id_fk",
+          "tableFrom": "upload_request_comments",
+          "tableTo": "upload_requests",
+          "columnsFrom": [
+            "request_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "upload_request_comments_author_id_users_id_fk": {
+          "name": "upload_request_comments_author_id_users_id_fk",
+          "tableFrom": "upload_request_comments",
+          "tableTo": "users",
+          "columnsFrom": [
+            "author_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "upload_request_comments_deleted_by_id_users_id_fk": {
+          "name": "upload_request_comments_deleted_by_id_users_id_fk",
+          "tableFrom": "upload_request_comments",
+          "tableTo": "users",
+          "columnsFrom": [
+            "deleted_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_request_fill_attempts": {
+      "name": "upload_request_fill_attempts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "request_id": {
+          "name": "request_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "torrent_id": {
+          "name": "torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'proposed'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "rejected_at": {
+          "name": "rejected_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "upload_request_fill_attempts_torrent_idx": {
+          "name": "upload_request_fill_attempts_torrent_idx",
+          "columns": [
+            {
+              "expression": "torrent_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_request_fill_attempts_user_idx": {
+          "name": "upload_request_fill_attempts_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_request_fill_attempts_request_user_idx": {
+          "name": "upload_request_fill_attempts_request_user_idx",
+          "columns": [
+            {
+              "expression": "request_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_request_fill_attempts_active_unique": {
+          "name": "upload_request_fill_attempts_active_unique",
+          "columns": [
+            {
+              "expression": "request_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "status = 'proposed'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "upload_request_fill_attempts_request_id_upload_requests_id_fk": {
+          "name": "upload_request_fill_attempts_request_id_upload_requests_id_fk",
+          "tableFrom": "upload_request_fill_attempts",
+          "tableTo": "upload_requests",
+          "columnsFrom": [
+            "request_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "upload_request_fill_attempts_user_id_users_id_fk": {
+          "name": "upload_request_fill_attempts_user_id_users_id_fk",
+          "tableFrom": "upload_request_fill_attempts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "upload_request_fill_attempts_torrent_id_torrents_id_fk": {
+          "name": "upload_request_fill_attempts_torrent_id_torrents_id_fk",
+          "tableFrom": "upload_request_fill_attempts",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_requests": {
+      "name": "upload_requests",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "requester_id": {
+          "name": "requester_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reward_points": {
+          "name": "reward_points",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'requested'"
+        },
+        "filled_by_id": {
+          "name": "filled_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filled_torrent_id": {
+          "name": "filled_torrent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filled_at": {
+          "name": "filled_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "validated_at": {
+          "name": "validated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cancelled_at": {
+          "name": "cancelled_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "federated_peer_id": {
+          "name": "federated_peer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "federated_info_hash": {
+          "name": "federated_info_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "federated_content_root_v2": {
+          "name": "federated_content_root_v2",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "upload_requests_category_idx": {
+          "name": "upload_requests_category_idx",
+          "columns": [
+            {
+              "expression": "category_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_requests_status_idx": {
+          "name": "upload_requests_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_requests_federated_info_hash_idx": {
+          "name": "upload_requests_federated_info_hash_idx",
+          "columns": [
+            {
+              "expression": "federated_info_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_requests_requester_idx": {
+          "name": "upload_requests_requester_idx",
+          "columns": [
+            {
+              "expression": "requester_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_requests_filled_at_idx": {
+          "name": "upload_requests_filled_at_idx",
+          "columns": [
+            {
+              "expression": "filled_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "upload_requests_requester_id_users_id_fk": {
+          "name": "upload_requests_requester_id_users_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "users",
+          "columnsFrom": [
+            "requester_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "upload_requests_category_id_categories_id_fk": {
+          "name": "upload_requests_category_id_categories_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "upload_requests_filled_by_id_users_id_fk": {
+          "name": "upload_requests_filled_by_id_users_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "users",
+          "columnsFrom": [
+            "filled_by_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "upload_requests_filled_torrent_id_torrents_id_fk": {
+          "name": "upload_requests_filled_torrent_id_torrents_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "torrents",
+          "columnsFrom": [
+            "filled_torrent_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "upload_requests_federated_peer_id_federation_peers_id_fk": {
+          "name": "upload_requests_federated_peer_id_federation_peers_id_fk",
+          "tableFrom": "upload_requests",
+          "tableTo": "federation_peers",
+          "columnsFrom": [
+            "federated_peer_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_rule_category_patterns": {
+      "name": "upload_rule_category_patterns",
+      "schema": "",
+      "columns": {
+        "category_id": {
+          "name": "category_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "pattern": {
+          "name": "pattern",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "upload_rule_category_patterns_category_id_categories_id_fk": {
+          "name": "upload_rule_category_patterns_category_id_categories_id_fk",
+          "tableFrom": "upload_rule_category_patterns",
+          "tableTo": "categories",
+          "columnsFrom": [
+            "category_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_rules": {
+      "name": "upload_rules",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "'singleton'"
+        },
+        "nfo_required": {
+          "name": "nfo_required",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "description_required": {
+          "name": "description_required",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "description_min_length": {
+          "name": "description_min_length",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "title_pattern_enforced": {
+          "name": "title_pattern_enforced",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "title_blocklist": {
+          "name": "title_blocklist",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tmdb_id_required": {
+          "name": "tmdb_id_required",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "max_torrent_size": {
+          "name": "max_torrent_size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "staff_bypass": {
+          "name": "staff_bypass",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.uploaded_fonts": {
+      "name": "uploaded_fonts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "family": {
+          "name": "family",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "storage_key": {
+          "name": "storage_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "bytes": {
+          "name": "bytes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sha256": {
+          "name": "sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "uploaded_by": {
+          "name": "uploaded_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "uploaded_fonts_role_idx": {
+          "name": "uploaded_fonts_role_idx",
+          "columns": [
+            {
+              "expression": "role",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "uploaded_fonts_uploaded_by_users_id_fk": {
+          "name": "uploaded_fonts_uploaded_by_users_id_fk",
+          "tableFrom": "uploaded_fonts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "uploaded_by"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "uploaded_fonts_sha256_unique": {
+          "name": "uploaded_fonts_sha256_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "sha256"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "uploaded_fonts_role_ck": {
+          "name": "uploaded_fonts_role_ck",
+          "value": "\"uploaded_fonts\".\"role\" IN ('sans', 'mono', 'display')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_follows": {
+      "name": "user_follows",
+      "schema": "",
+      "columns": {
+        "follower_id": {
+          "name": "follower_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "following_id": {
+          "name": "following_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "user_follows_following_idx": {
+          "name": "user_follows_following_idx",
+          "columns": [
+            {
+              "expression": "following_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_follows_follower_id_users_id_fk": {
+          "name": "user_follows_follower_id_users_id_fk",
+          "tableFrom": "user_follows",
+          "tableTo": "users",
+          "columnsFrom": [
+            "follower_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_follows_following_id_users_id_fk": {
+          "name": "user_follows_following_id_users_id_fk",
+          "tableFrom": "user_follows",
+          "tableTo": "users",
+          "columnsFrom": [
+            "following_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_follows_follower_id_following_id_pk": {
+          "name": "user_follows_follower_id_following_id_pk",
+          "columns": [
+            "follower_id",
+            "following_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_message_keys": {
+      "name": "user_message_keys",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "alg": {
+          "name": "alg",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'ECDH-P256'"
+        },
+        "device_label": {
+          "name": "device_label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "user_message_keys_user_id_users_id_fk": {
+          "name": "user_message_keys_user_id_users_id_fk",
+          "tableFrom": "user_message_keys",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_notification_channels": {
+      "name": "user_notification_channels",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "channel_type": {
+          "name": "channel_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "user_config": {
+          "name": "user_config",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "''"
+        },
+        "last_test_status": {
+          "name": "last_test_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_test_error": {
+          "name": "last_test_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_tested_at": {
+          "name": "last_tested_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "consecutive_failures": {
+          "name": "consecutive_failures",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "user_notification_channels_user_type_unique": {
+          "name": "user_notification_channels_user_type_unique",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "channel_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_notification_channels_user_id_users_id_fk": {
+          "name": "user_notification_channels_user_id_users_id_fk",
+          "tableFrom": "user_notification_channels",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_notification_routing": {
+      "name": "user_notification_routing",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "channel_type": {
+          "name": "channel_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "user_notification_routing_pk": {
+          "name": "user_notification_routing_pk",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "user_notification_routing_user_idx": {
+          "name": "user_notification_routing_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_notification_routing_user_id_users_id_fk": {
+          "name": "user_notification_routing_user_id_users_id_fk",
+          "tableFrom": "user_notification_routing",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_roles": {
+      "name": "user_roles",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role_id": {
+          "name": "role_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "assigned_at": {
+          "name": "assigned_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "assigned_manually": {
+          "name": "assigned_manually",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        }
+      },
+      "indexes": {
+        "user_roles_role_idx": {
+          "name": "user_roles_role_idx",
+          "columns": [
+            {
+              "expression": "role_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_roles_user_id_users_id_fk": {
+          "name": "user_roles_user_id_users_id_fk",
+          "tableFrom": "user_roles",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_roles_role_id_roles_id_fk": {
+          "name": "user_roles_role_id_roles_id_fk",
+          "tableFrom": "user_roles",
+          "tableTo": "roles",
+          "columnsFrom": [
+            "role_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_roles_user_id_role_id_pk": {
+          "name": "user_roles_user_id_role_id_pk",
+          "columns": [
+            "user_id",
+            "role_id"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_signing_keys": {
+      "name": "user_signing_keys",
+      "schema": "",
+      "columns": {
+        "did": {
+          "name": "did",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "private_key_enc": {
+          "name": "private_key_enc",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "revoked_at": {
+          "name": "revoked_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "succeeded_by": {
+          "name": "succeeded_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "user_signing_keys_current": {
+          "name": "user_signing_keys_current",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "revoked_at IS NULL",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "user_signing_keys_user_idx": {
+          "name": "user_signing_keys_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_signing_keys_user_id_users_id_fk": {
+          "name": "user_signing_keys_user_id_users_id_fk",
+          "tableFrom": "user_signing_keys",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "auth_salt": {
+          "name": "auth_salt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "auth_verifier": {
+          "name": "auth_verifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "passkey": {
+          "name": "passkey",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rss_key": {
+          "name": "rss_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "api_key": {
+          "name": "api_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_admin": {
+          "name": "is_admin",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_moderator": {
+          "name": "is_moderator",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_owner": {
+          "name": "is_owner",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "session_epoch": {
+          "name": "session_epoch",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "is_banned": {
+          "name": "is_banned",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "banned_by_id": {
+          "name": "banned_by_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "banned_by_role": {
+          "name": "banned_by_role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "banned_until": {
+          "name": "banned_until",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ban_reason": {
+          "name": "ban_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_ip": {
+          "name": "last_ip",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "uploaded": {
+          "name": "uploaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "bonus_uploaded": {
+          "name": "bonus_uploaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "downloaded": {
+          "name": "downloaded",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "invites_remaining": {
+          "name": "invites_remaining",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "bonus_points": {
+          "name": "bonus_points",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "panic_password_hash": {
+          "name": "panic_password_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "bio": {
+          "name": "bio",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "show_last_seen": {
+          "name": "show_last_seen",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "show_adult_content": {
+          "name": "show_adult_content",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "messaging_read_receipts": {
+          "name": "messaging_read_receipts",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "anonymous_uploads": {
+          "name": "anonymous_uploads",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "hide_download_history": {
+          "name": "hide_download_history",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "restrict_comments": {
+          "name": "restrict_comments",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "share_reputation_federated": {
+          "name": "share_reputation_federated",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "theme": {
+          "name": "theme",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "language": {
+          "name": "language",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'en'"
+        },
+        "catalogue_defaults": {
+          "name": "catalogue_defaults",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "totp_secret": {
+          "name": "totp_secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "totp_enabled": {
+          "name": "totp_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "trust_devices_enabled": {
+          "name": "trust_devices_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_seen": {
+          "name": "last_seen",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "users_owner_unique": {
+          "name": "users_owner_unique",
+          "columns": [
+            {
+              "expression": "is_owner",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"users\".\"is_owner\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "users_username_lower_unique": {
+          "name": "users_username_lower_unique",
+          "columns": [
+            {
+              "expression": "lower(\"username\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "users_username_unique": {
+          "name": "users_username_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "username"
+          ]
+        },
+        "users_passkey_unique": {
+          "name": "users_passkey_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "passkey"
+          ]
+        },
+        "users_rss_key_unique": {
+          "name": "users_rss_key_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "rss_key"
+          ]
+        },
+        "users_api_key_unique": {
+          "name": "users_api_key_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "api_key"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.webauthn_credentials": {
+      "name": "webauthn_credentials",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "credential_id": {
+          "name": "credential_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "public_key": {
+          "name": "public_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "counter": {
+          "name": "counter",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "transports": {
+          "name": "transports",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_used_at": {
+          "name": "last_used_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "webauthn_credentials_user_idx": {
+          "name": "webauthn_credentials_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "webauthn_credentials_user_id_users_id_fk": {
+          "name": "webauthn_credentials_user_id_users_id_fk",
+          "tableFrom": "webauthn_credentials",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "webauthn_credentials_credential_id_unique": {
+          "name": "webauthn_credentials_credential_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "credential_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.work_titles": {
+      "name": "work_titles",
+      "schema": "",
+      "columns": {
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "external_id": {
+          "name": "external_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "bare_id": {
+          "name": "bare_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "locale": {
+          "name": "locale",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "original_title": {
+          "name": "original_title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "year": {
+          "name": "year",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "work_titles_bare_idx": {
+          "name": "work_titles_bare_idx",
+          "columns": [
+            {
+              "expression": "source",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "bare_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "work_titles_fts_idx": {
+          "name": "work_titles_fts_idx",
+          "columns": [
+            {
+              "expression": "to_tsvector('simple', coalesce(translate(\"title\", '._', '  '), ''))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "work_titles_trgm_idx": {
+          "name": "work_titles_trgm_idx",
+          "columns": [
+            {
+              "expression": "\"title\" gin_trgm_ops",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {
+        "work_titles_source_external_id_locale_pk": {
+          "name": "work_titles_source_external_id_locale_pk",
+          "columns": [
+            "source",
+            "external_id",
+            "locale"
+          ]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
\ No newline at end of file
diff --git a/packages/db/src/migrations/meta/_journal.json b/packages/db/src/migrations/meta/_journal.json
index 78878344..f6709544 100644
--- a/packages/db/src/migrations/meta/_journal.json
+++ b/packages/db/src/migrations/meta/_journal.json
@@ -512,6 +512,34 @@
       "when": 1788396546278,
       "tag": "0072_hnr_fillfactor_correction",
       "breakpoints": true
+    },
+    {
+      "idx": 73,
+      "version": "7",
+      "when": 1788606661855,
+      "tag": "0073_torrent_stats_history",
+      "breakpoints": true
+    },
+    {
+      "idx": 74,
+      "version": "7",
+      "when": 1788723354637,
+      "tag": "0074_saved_searches_seen_count",
+      "breakpoints": true
+    },
+    {
+      "idx": 75,
+      "version": "7",
+      "when": 1788725374593,
+      "tag": "0075_fts_split_dotted_names",
+      "breakpoints": true
+    },
+    {
+      "idx": 76,
+      "version": "7",
+      "when": 1788732055953,
+      "tag": "0076_catalogue_alerts_titles_misses",
+      "breakpoints": true
     }
   ]
-}
+}
\ No newline at end of file
diff --git a/packages/db/src/schema.ts b/packages/db/src/schema.ts
index c662c91d..ac385ffb 100644
--- a/packages/db/src/schema.ts
+++ b/packages/db/src/schema.ts
@@ -2,6 +2,7 @@ import {
   pgTable,
   text,
   timestamp,
+  date,
   integer,
   smallint,
   bigint,
@@ -245,6 +246,12 @@ export const users = pgTable(
     // module's `defaultLocale`; missing keys in any locale fall back
     // to English at render time.
     language: text('language').default('en').notNull(),
+    /*
+     * Les filtres par défaut du catalogue, sous la forme exacte de sa chaîne
+     * de requête (tk, se, ep, y, u, o, c, v, s, d) : un membre qui veut
+     * toujours VOSTFR en 1080p le pose une fois. NULL : la page s'ouvre nue.
+     */
+    catalogueDefaults: jsonb('catalogue_defaults').$type<Record<string, string>>(),
     // ── Two-factor authentication ────────────────────────────
     // TOTP secret stored as base32 (the `otpauth://` URI form).
     // Encryption-at-rest is left to the operator's Postgres setup;
@@ -1526,6 +1533,35 @@ export const torrentStats = pgTable(
   ]
 );
 
+/**
+ * Un point par torrent et par jour : ce que l'essaim valait la dernière fois
+ * que le collecteur l'a regardé ce jour-là.
+ *
+ * `torrent_stats` est un INSTANTANÉ, réécrit à chaque passe : il dit combien de
+ * sources il y a maintenant, jamais s'il y en avait plus hier. Or c'est cette
+ * tendance qui répond à « est-ce que ça va descendre ? » — une release à trois
+ * sources qui en avait douze la semaine dernière meurt ; à trois sources qui en
+ * avait zéro, elle revit. La fiche d'un torrent trace ces points en courbe.
+ *
+ * Écrite par `stats-collector` à la fin de chaque passe COMPLÈTE (un balayage
+ * tronqué ne voit qu'un sous-ensemble arbitraire et fausserait la courbe),
+ * la dernière valeur du jour remplace la précédente, et tout ce qui a plus de
+ * trente jours est élagué dans le même mouvement. Une ligne par torrent et par
+ * jour : 100 000 torrents coûtent 3 millions de lignes de 40 octets au plus.
+ */
+export const torrentStatsHistory = pgTable(
+  'torrent_stats_history',
+  {
+    infoHash: text('info_hash')
+      .notNull()
+      .references(() => torrents.infoHash, { onDelete: 'cascade' }),
+    day: date('day').notNull(),
+    seeders: integer('seeders').default(0).notNull(),
+    leechers: integer('leechers').default(0).notNull(),
+  },
+  (table) => [primaryKey({ columns: [table.infoHash, table.day] })]
+);
+
 // ============================================================================
 // Announce Log (For tracking/debugging, optional)
 // ============================================================================
@@ -2623,6 +2659,59 @@ export type NewUserFollow = typeof userFollows.$inferInsert;
 // index. A user deletion drops their favorites; a torrent deletion
 // drops every favorite that referenced it (cleaner than leaving
 // dangling rows for the /me/favorites page to filter out).
+/**
+ * Les titres des œuvres, tels que les fournisseurs de métadonnées les donnent.
+ *
+ * La recherche plein texte ne lisait que les noms de fichiers : « frieren »
+ * trouvait `Sousou.no.Frieren…` mais rien d'une release nommée autrement, et
+ * « Frieren: Beyond Journey's End » n'existait nulle part dans l'index. Chaque
+ * lookup de métadonnées dépose ici le titre et le titre original, par langue ;
+ * la recherche les lit par l'identifiant externe du torrent, et l'état vide
+ * s'en sert pour « vouliez-vous dire » (trigrammes).
+ *
+ * `bareId` : la partie numérique d'un identifiant TMDb (`tv/209867` → `209867`),
+ * parce que les torrents portent tantôt la forme préfixée, tantôt la forme nue.
+ */
+export const workTitles = pgTable(
+  'work_titles',
+  {
+    source: text('source').notNull(),
+    externalId: text('external_id').notNull(),
+    bareId: text('bare_id').notNull(),
+    locale: text('locale').notNull(),
+    title: text('title').notNull(),
+    originalTitle: text('original_title'),
+    year: smallint('year'),
+    updatedAt: timestamp('updated_at').defaultNow().notNull(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.source, table.externalId, table.locale] }),
+    index('work_titles_bare_idx').on(table.source, table.bareId),
+    index('work_titles_fts_idx').using('gin', ftsVector(table.title)),
+    index('work_titles_trgm_idx').using('gin', sql`${table.title} gin_trgm_ops`),
+  ]
+);
+
+/**
+ * Ce que les membres cherchent sans rien trouver.
+ *
+ * Une recherche à zéro résultat est la meilleure liste d'acquisition possible :
+ * elle dit ce qui manque, avec la fréquence. Une ligne par requête normalisée
+ * (minuscules, espaces repliés), un compteur, la première et la dernière fois.
+ * Alimentée par le listing quand la page 1 rend zéro sur au moins trois
+ * caractères ; lue par l'administration.
+ */
+export const searchMisses = pgTable(
+  'search_misses',
+  {
+    query: text('query').primaryKey(),
+    count: integer('count').default(1).notNull(),
+    firstAt: timestamp('first_at').defaultNow().notNull(),
+    lastAt: timestamp('last_at').defaultNow().notNull(),
+  },
+  (table) => [index('search_misses_count_idx').on(table.count.desc(), table.lastAt.desc())]
+);
+
 export const torrentFavorites = pgTable(
   'torrent_favorites',
   {
@@ -2903,6 +2992,26 @@ export const savedSearches = pgTable(
     createdAt: timestamp('created_at').defaultNow().notNull(),
     lastMatchedAt: timestamp('last_matched_at'),
     matchCount: integer('match_count').default(0).notNull(),
+    /*
+     * Ce que le membre a déjà VU de ces correspondances. La différence avec
+     * `matchCount` est le « n nouv. » du bandeau d'alertes du catalogue ; elle
+     * retombe à zéro quand il ouvre l'alerte depuis là. Un compteur plutôt
+     * qu'une date : `matchCount` ne recule jamais, la soustraction suffit.
+     */
+    seenCount: integer('seen_count').default(0).notNull(),
+    /*
+     * Les critères de la barre du catalogue, tels qu'elle les produit :
+     * `tagGroups` (« hevc,x265;1080p » — OU dans un groupe, ET entre eux),
+     * saison, épisode, année (portée par le nom), et l'uploadeur résolu en id
+     * à l'enregistrement. Sans eux, « frieren 1080p s02 @kaf » enregistré ne
+     * gardait que le texte et un slug : l'alerte ne reproduisait pas la
+     * recherche qu'on avait sous les yeux.
+     */
+    tagGroups: text('tag_groups'),
+    season: smallint('season'),
+    episode: smallint('episode'),
+    year: smallint('year'),
+    uploaderId: text('uploader_id').references(() => users.id, { onDelete: 'set null' }),
   },
   (table) => [
     /** les alertes d'une catégorie. */
diff --git a/packages/db/src/search.ts b/packages/db/src/search.ts
index 6cb7227a..0b930587 100644
--- a/packages/db/src/search.ts
+++ b/packages/db/src/search.ts
@@ -41,5 +41,13 @@ export function ftsVector(column: AnyColumn | SQL): SQL {
   // even in the query position it would stop the planner from matching the
   // indexed expression, silently turning every search into a sequential scan.
   // `FTS_CONFIG` is a module constant, never user input.
-  return sql`to_tsvector(${sql.raw(`'${FTS_CONFIG}'`)}, coalesce(${column}, ''))`;
+  //
+  // `translate(…, '._', '  ')` : un nom de release s'écrit
+  // `Sousou.no.Frieren.S01E09.VOSTFR.1080p.WEBRip` — pour l'analyseur de
+  // Postgres, c'est UN jeton (une forme d'hôte ou de fichier), et « frieren »
+  // n'y trouvait qu'une release sur neuf ; le repli approximatif masquait le
+  // trou tant que la recherche exacte rendait zéro. Les points et soulignés
+  // deviennent des espaces avant la vectorisation, dans l'index comme dans le
+  // prédicat ; les tirets restent, l'analyseur les découpe déjà.
+  return sql`to_tsvector(${sql.raw(`'${FTS_CONFIG}'`)}, coalesce(translate(${column}, '._', '  '), ''))`;
 }
diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
index f90f0101..00782515 100644
--- a/packages/shared/src/index.ts
+++ b/packages/shared/src/index.ts
@@ -58,6 +58,9 @@ export const TORRENT_SORT_KEYS = [
   'completed',
   'size',
   'age',
+  // Not a column: the text-search rank, meaningful only while a text is typed.
+  // The catalogue picks it by itself when the sort is left on "auto".
+  'relevance',
 ] as const;
 
 export type TorrentSortKey = (typeof TORRENT_SORT_KEYS)[number];
diff --git a/tests/e2e/.gitignore b/tests/e2e/.gitignore
index 8a411b7b..f6569365 100644
--- a/tests/e2e/.gitignore
+++ b/tests/e2e/.gitignore
@@ -1,2 +1,3 @@
-session.json
+session*.json
 crypto.mjs
+tmdb.env
diff --git a/tests/e2e/README.md b/tests/e2e/README.md
index c51be2ae..680fb5f1 100644
--- a/tests/e2e/README.md
+++ b/tests/e2e/README.md
@@ -27,16 +27,45 @@ Useful flags:
 - `--keep` — leave the stack running afterwards, for poking at
   <http://localhost:53000> (web) and <http://localhost:54000> (api)
 
-Two scripts fill a kept stack with something worth looking at. Neither asserts
-anything, so neither is a scenario, and `run.sh` does not call them:
+Four scripts fill a kept stack with something worth looking at. None asserts
+anything, so none is a scenario, and `run.sh` does not call them:
 
 ```bash
 node tests/e2e/demo.mjs          # roles, both messaging surfaces, a room
 node tests/e2e/forumTickets.mjs  # three forum categories, six topics, five tickets
+node tests/e2e/demoTorrents.mjs  # ten releases, a cross-seed, a supersession, a swarm
+node tests/e2e/demoSwarm.mjs     # a swarm for every torrent already in the catalogue
 ```
 
-Both go through HTTP like the seeder, and both are re-runnable: a topic or a
-ticket whose subject is already there is skipped rather than duplicated.
+All four go through HTTP like the seeder, and all four are re-runnable: a topic,
+a ticket or a torrent that is already there is skipped rather than duplicated,
+and `demoSwarm` derives each peer_id from the infohash so a second run
+re-announces the same peers instead of doubling the swarm.
+
+### A real catalogue
+
+Hand-made fixtures are clean by construction, which is exactly what a layout is
+not tested by. To fill the stack from an operator's own `pg_dump` instead:
+
+```bash
+bash tests/e2e/import-dump.sh /path/to/dump.sql
+node tests/e2e/demoSwarm.mjs
+```
+
+It takes `torrents` and what hangs off it — categories, tags, links, comments,
+the swarm snapshot, favourites, moderation threads, seed obligations. It does
+**not** take the `users` table: that one carries `auth_verifier`, `passkey`,
+`totp_secret` and `panic_password_hash`, so uploader and author ids are remapped
+onto the harness accounts instead. The dump may come from an older schema — the
+columns are read from its own `COPY` headers and checked against the running
+database, and the import refuses to start if one has since disappeared.
+
+### TMDb
+
+`tests/e2e/tmdb.env` is read by the `api` service if it exists, and `run.sh`
+writes it from the repository's own `.env`. Without a key the stack works
+perfectly well — but every detail page then renders its "no poster" substitute,
+which for a long time was the only state anybody had ever looked at.
 - `--no-build` — reuse the images from the last run
 - `--only themes` — run one scenario file
 
@@ -44,9 +73,12 @@ ticket whose subject is already there is skipped rather than duplicated.
 
 Deliberately lean: no PgBouncer (the API talks to Postgres directly, which is
 what `MIGRATIONS_DATABASE_URL` does in production anyway), no Caddy (the web
-container emits its own CSP, so the policy under test is the real one), no
-tracker (nothing here announces). Ports are shifted into the 5xxxx range so it
-cannot collide with a development stack.
+container emits its own CSP, so the policy under test is the real one). Ports
+are shifted into the 5xxxx range so it cannot collide with a development stack.
+
+The tracker **is** here, on port 54200, even though no scenario announces. It
+earns its build because without it every swarm renders empty — and a page that
+only ever shows its zero-seeder state has never really been looked at.
 
 Every secret in `docker-compose.yml` is obviously fake and hardcoded. This stack
 is not reachable from anywhere and is destroyed at the end of a run.
diff --git a/tests/e2e/demoSwarm.mjs b/tests/e2e/demoSwarm.mjs
new file mode 100644
index 00000000..c17ea463
--- /dev/null
+++ b/tests/e2e/demoSwarm.mjs
@@ -0,0 +1,164 @@
+/**
+ * Donne un essaim à tout le catalogue d'une pile gardée.
+ *
+ * `demoTorrents.mjs` annonce pour les dix releases qu'il dépose lui-même. Dès
+ * qu'un catalogue arrive par un autre chemin — une restauration de sauvegarde,
+ * un import — ces torrents-là n'ont aucun pair, et chaque page de détail rend
+ * son état « zéro seeder » : la carte de décision propose une remise en
+ * partage, le tableau des pairs affiche son vide, et le dock annonce 0/0. Ce
+ * n'est pas faux, mais c'est le seul état qu'on regarde alors, sur toutes les
+ * pages à la fois.
+ *
+ *   node tests/e2e/demoSwarm.mjs
+ *
+ * Ce que ce script ne fait PAS : reprendre les compteurs d'une sauvegarde. La
+ * table `torrent_stats` est un instantané que le collecteur réécrit ; les
+ * chiffres qu'une page de détail affiche viennent de Redis, donc de vraies
+ * annonces. La forme de chaque essaim est donc DÉRIVÉE de l'infohash —
+ * déterministe, donc une relance réannonce les mêmes pairs au lieu de doubler
+ * l'essaim, et deux torrents n'ont pas le même nombre de seeders.
+ *
+ * Comme `demo.mjs`, ce script n'asserte rien : ce n'est pas un scénario.
+ */
+import { API, announce, passkeyOf, resetRateLimits, sessions, sleep } from './lib.mjs';
+
+/* Les comptes du harnais, plus ceux que `demoTorrents.mjs` a inscrits. Un pair
+   est rattaché au membre dont la passkey a servi à l'annonce : sans plusieurs
+   comptes, un essaim plafonne à une ligne. */
+const EXTRA_CACHE = new URL('./session-torrents.json', import.meta.url);
+
+/** Combien de pairs, et lesquels, pour un torrent donné. */
+function shapeFor(infoHash, memberCount) {
+  // Deux octets de l'infohash suffisent : on veut une variété stable, pas de
+  // l'aléatoire. Au moins un seeder — un catalogue où rien n'est disponible
+  // n'apprend rien de plus qu'un catalogue vide.
+  const a = parseInt(infoHash.slice(0, 2), 16);
+  const b = parseInt(infoHash.slice(2, 4), 16);
+  const seeders = 1 + (a % Math.max(1, Math.min(memberCount, 5)));
+  const leechers = b % 3;
+  return { seeders, leechers: Math.min(leechers, Math.max(0, memberCount - seeders)) };
+}
+
+async function main() {
+  const S = sessions(['founder']);
+
+  let extra = {};
+  try {
+    const { readFileSync } = await import('node:fs');
+    extra = JSON.parse(readFileSync(EXTRA_CACHE, 'utf8'));
+  } catch {
+    // Absent : la pile n'a que les trois comptes du seed. Les essaims seront
+    // plus petits, rien de plus.
+  }
+
+  const cookies = Object.fromEntries([
+    ...Object.entries(S).map(([k, v]) => [k, v.cookie]),
+    ...Object.entries(extra).map(([k, v]) => [k, v.cookie]),
+  ]);
+
+  await resetRateLimits().catch(() => {});
+
+  console.log('\n1. passkeys');
+  const members = [];
+  for (const [who, cookie] of Object.entries(cookies)) {
+    const pk = await passkeyOf(cookie);
+    if (pk) members.push({ who, passkey: pk });
+  }
+  console.log(`   ${members.length} membres : ${members.map((m) => m.who).join(' ')}`);
+  if (!members.length) {
+    console.error('aucune passkey — la pile est-elle bien celle du seed ?');
+    process.exit(1);
+  }
+
+  console.log('\n2. catalogue');
+  // Le catalogue est lu AVEC LES YEUX DE `founder`, et c'est une contrainte,
+  // pas un détail : `/api/torrents` décide de montrer l'adulte d'après la
+  // colonne `show_adult_content` de l'APPELANT, jamais d'après un paramètre de
+  // requête. Un `?showAdultContent=true` dans l'URL ne fait rien du tout — zod
+  // le retire, le schéma ne le déclare pas. Les lignes en attente, elles,
+  // sortent parce que l'appelant est administrateur.
+  //
+  // Donc si le compte n'a pas activé l'adulte, ces torrents-là n'auront pas
+  // d'essaim, et le compte rendu final le dit plutôt que de le taire.
+  const items = [];
+  for (let page = 1; page <= 20; page += 1) {
+    const res = await fetch(
+      `${API}/api/torrents?limit=100&page=${page}`,
+      { headers: { cookie: S.founder.cookie } },
+    );
+    if (!res.ok) break;
+    const body = await res.json();
+    const batch = body?.data ?? [];
+    items.push(...batch);
+    if (batch.length < 100 || page >= (body?.pagination?.pages ?? 1)) break;
+  }
+  const total = items.length;
+  console.log(`   ${total} torrents visibles par founder`);
+
+  console.log('\n3. annonces');
+  let announced = 0;
+  let refused = 0;
+  let skipped = 0;
+  for (const t of items) {
+    if (!t?.infoHash || typeof t.size !== 'number') {
+      skipped += 1;
+      continue;
+    }
+    const { seeders, leechers } = shapeFor(t.infoHash, members.length);
+    const picked = [];
+    for (let i = 0; i < seeders + leechers; i += 1) {
+      // Décalage par l'infohash : ce n'est pas toujours `founder` qui seede.
+      const offset = parseInt(t.infoHash.slice(4, 6), 16);
+      picked.push(members[(offset + i) % members.length]);
+    }
+    for (let i = 0; i < picked.length; i += 1) {
+      const m = picked[i];
+      const isSeeder = i < seeders;
+      const seed = `${t.infoHash}:${m.who}`;
+      const port = 6881 + (i % 32);
+      const first = await announce(m.passkey, t.infoHash, seed, {
+        left: isSeeder ? t.size : Math.round(t.size * (0.15 + 0.7 * ((i + 1) / 8))),
+        downloaded: 0,
+        event: 'started',
+        port,
+      });
+      if (first.failure) {
+        refused += 1;
+        if (refused <= 3) console.log(`   refus  ${m.who} -> ${t.infoHash.slice(0, 10)} : ${first.failure}`);
+        continue;
+      }
+      if (isSeeder) {
+        // La seconde annonce ferme le téléchargement : c'est elle qui compte un
+        // snatch et qui fait passer le pair de leecher à seeder.
+        await announce(m.passkey, t.infoHash, seed, {
+          left: 0,
+          uploaded: Math.round(t.size * (0.3 + (i % 4))),
+          downloaded: t.size,
+          event: 'completed',
+          port,
+        });
+      }
+      announced += 1;
+    }
+    await sleep(40);
+  }
+  console.log(`   ${announced} pairs posés, ${refused} refusés, ${skipped} torrents ignorés`);
+  if (refused) {
+    console.log(
+      '   Un refus « Torrent not found or inactive » est le tracker qui fait son travail :',
+    );
+    console.log(
+      '   une ligne en attente de modération n\'est pas annonçable, et ne doit pas l\'être.',
+    );
+  }
+
+  // Le versement des crédits d'octets est groupé (5 s dans cette pile).
+  console.log('\n   attente du versement des crédits (7 s)…');
+  await sleep(7000);
+  console.log('\nfini.');
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
diff --git a/tests/e2e/demoTorrents.mjs b/tests/e2e/demoTorrents.mjs
new file mode 100644
index 00000000..634386d2
--- /dev/null
+++ b/tests/e2e/demoTorrents.mjs
@@ -0,0 +1,1237 @@
+/**
+ * Remplit une pile e2e gardée de torrents qui valent le coup d'œil.
+ *
+ * `demo.mjs` fabrique des rôles, des conversations et un salon — tout sauf des
+ * torrents. `torrentVisibility.mjs` en dépose bien quatre, mais ce sont des
+ * fixtures d'assertion : des noms comme `e2e-vis-public-accepted`, aucune
+ * description, aucun NFO, aucun pair. Une page de détail nourrie de ça ne
+ * montre que ses états vides, et c'est exactement ce qu'on ne peut pas juger.
+ *
+ * Ce script construit donc ce que la page est censée rendre :
+ *
+ *   - des noms de release réels, parce que les pastilles de qualité sont
+ *     ANALYSÉES depuis le nom (`releaseChips.ts`) et non stockées ;
+ *   - un bloc MediaInfo dans le NFO, parce que les tables de pistes audio et
+ *     de sous-titres sont analysées depuis ce texte — le schéma n'a aucune
+ *     colonne par piste (voir l'en-tête de `TrackTables.vue`) ;
+ *   - une description en BBCode, pour que `DescriptionRender` ait de quoi
+ *     faire et que le pavé de l'uploadeur pèse ce qu'il pèse en vrai ;
+ *   - un cross-seed VRAI : même liste de fichiers, `piece length` différente,
+ *     donc même `content_signature` et un info_hash distinct ;
+ *   - un groupe : deux éditions du même film sous le même `tmdbId`, ce qui est
+ *     la seule façon de voir la table des versions se remplir ;
+ *   - une supersession, un freeleech avec échéance, un épinglage ;
+ *   - des commentaires, un favori, une obligation de seed ;
+ *   - un essaim, en annonçant sur le VRAI tracker avec la VRAIE passkey de
+ *     chaque compte.
+ *
+ *   node tests/e2e/demoTorrents.mjs
+ *
+ * Rejouable : un torrent déjà déposé est repris tel quel plutôt que dupliqué,
+ * et les comptes déjà inscrits se connectent.
+ *
+ * Comme `demo.mjs`, ce script n'asserte rien — ce n'est pas un scénario, et
+ * `run.sh` ne l'appelle pas.
+ */
+import { createHash, randomBytes } from 'node:crypto';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { generateCredentials, generateLoginProof, solvePoW } from './crypto.mjs';
+import { announce, resetRateLimits } from './lib.mjs';
+
+const API = process.env.E2E_API ?? 'http://localhost:54000';
+const WEB = process.env.E2E_WEB ?? 'http://localhost:53000';
+const HERE = new URL('.', import.meta.url);
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+const S = JSON.parse(readFileSync(new URL('session.json', HERE), 'utf8'));
+
+/* ── HTTP ─────────────────────────────────────────────────────────────────── */
+
+const jars = new Map();
+const jarFor = (name) => {
+  if (!jars.has(name)) jars.set(name, new Map());
+  return jars.get(name);
+};
+const cookieHeader = (jar) => [...jar.entries()].map(([k, v]) => `${k}=${v}`).join('; ');
+function absorb(jar, res) {
+  for (const raw of res.headers.getSetCookie?.() ?? []) {
+    const [pair] = raw.split(';');
+    const i = pair.indexOf('=');
+    if (i > 0) jar.set(pair.slice(0, i).trim(), pair.slice(i + 1).trim());
+  }
+}
+
+/** Le cookie d'un compte : celui du seed pour les trois de base, le jar sinon. */
+function cookieOf(who) {
+  if (S[who]?.cookie) return S[who].cookie;
+  const jar = jarFor(who);
+  return jar.size ? cookieHeader(jar) : '';
+}
+
+async function call(path, { method = 'GET', body, who, jar, raw = false } = {}) {
+  const headers = {};
+  if (body !== undefined) headers['content-type'] = 'application/json';
+  const cookie = jar ? cookieHeader(jar) : who ? cookieOf(who) : '';
+  if (cookie) headers.cookie = cookie;
+  const res = await fetch(API + path, {
+    method,
+    headers,
+    body: body === undefined ? undefined : JSON.stringify(body),
+    redirect: 'manual',
+  });
+  if (jar) absorb(jar, res);
+  if (raw) return { status: res.status, buffer: Buffer.from(await res.arrayBuffer()) };
+  const text = await res.text();
+  let parsed = null;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = text;
+  }
+  return { status: res.status, body: parsed };
+}
+
+const ok = (s) => s >= 200 && s < 300;
+let steps = 0;
+let problems = 0;
+const step = (label, good, detail = '') => {
+  steps += 1;
+  if (!good) problems += 1;
+  console.log(`  ${good ? 'ok  ' : 'FAIL'} ${label}${detail ? `   ${detail}` : ''}`);
+};
+
+/* ── bencode ──────────────────────────────────────────────────────────────── */
+//
+// Repris de `torrentVisibility.mjs` : le harnais est délibérément sans
+// dépendance, et une deuxième implémentation d'un encodeur de dix lignes coûte
+// moins qu'un paquet à auditer.
+
+function bencode(value) {
+  if (Buffer.isBuffer(value)) return Buffer.concat([Buffer.from(`${value.length}:`), value]);
+  if (typeof value === 'string') return bencode(Buffer.from(value, 'utf8'));
+  if (typeof value === 'number') return Buffer.from(`i${Math.trunc(value)}e`);
+  if (Array.isArray(value)) {
+    return Buffer.concat([Buffer.from('l'), ...value.map(bencode), Buffer.from('e')]);
+  }
+  if (value && typeof value === 'object') {
+    // Clés en ordre lexicographique : sans ça l'info_hash calculé n'est pas
+    // celui qu'un client calculerait.
+    const keys = Object.keys(value).sort();
+    return Buffer.concat([
+      Buffer.from('d'),
+      ...keys.flatMap((k) => [bencode(k), bencode(value[k])]),
+      Buffer.from('e'),
+    ]);
+  }
+  throw new Error(`cannot bencode ${typeof value}`);
+}
+
+/**
+ * Un .torrent multi-fichiers.
+ *
+ * Les hachages de pièces sont dérivés du nom, pas d'un contenu : rien sur le
+ * chemin d'upload ne les vérifie, il lui faut vingt octets par pièce. Ce qui
+ * compte ici c'est que la liste de fichiers soit réelle, parce que c'est elle
+ * que `computeContentSignature` canonise — et donc elle qui décide de ce qui
+ * est un cross-seed de quoi.
+ *
+ * `pieceLength` est un paramètre pour cette raison précise : le passer à une
+ * autre puissance de deux change l'info_hash SANS changer la signature de
+ * contenu. C'est la définition d'un cross-seed, et c'est comment on en
+ * fabrique un.
+ *
+ * Le nombre de pièces est plafonné : 82 Gio en pièces de 4 Mio, ce sont 21 000
+ * hachages, soit 420 Kio de `pieces` — au-dessus de la limite de taille du
+ * .torrent envoyé, et sans utilité ici puisque personne ne vérifie un octet.
+ */
+function torrentFile({ name, files, pieceLength = 4 * 1024 * 1024 }) {
+  const total = files.reduce((n, f) => n + f.length, 0);
+  const count = Math.min(512, Math.max(1, Math.ceil(total / pieceLength)));
+  const pieces = Buffer.concat(
+    Array.from({ length: count }, (_, i) =>
+      createHash('sha1').update(`${name}:${pieceLength}:${i}`).digest(),
+    ),
+  );
+  return bencode({
+    announce: 'http://tracker.e2e.test/announce',
+    'created by': 'trackarr-e2e/demoTorrents',
+    'creation date': Math.floor(Date.now() / 1000),
+    info: {
+      files: files.map((f) => ({ length: f.length, path: f.path.split('/') })),
+      name,
+      'piece length': pieceLength,
+      pieces,
+      private: 1,
+    },
+  });
+}
+
+/** L'upload est multipart ; `call` parle JSON, donc celui-ci est à la main. */
+async function upload(who, fields, torrentBytes) {
+  const boundary = `----trackarr${randomBytes(8).toString('hex')}`;
+  const parts = [];
+  const field = (headers, body) => {
+    parts.push(Buffer.from(`--${boundary}\r\n${headers}\r\n\r\n`), body, Buffer.from('\r\n'));
+  };
+  field(
+    'Content-Disposition: form-data; name="torrent"; filename="release.torrent"\r\n' +
+      'Content-Type: application/x-bittorrent',
+    torrentBytes,
+  );
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === undefined || value === null || value === '') continue;
+    field(`Content-Disposition: form-data; name="${key}"`, Buffer.from(String(value), 'utf8'));
+  }
+  parts.push(Buffer.from(`--${boundary}--\r\n`));
+
+  const res = await fetch(`${API}/api/torrents`, {
+    method: 'POST',
+    headers: {
+      cookie: cookieOf(who),
+      'content-type': `multipart/form-data; boundary=${boundary}`,
+    },
+    body: Buffer.concat(parts),
+  });
+  const text = await res.text();
+  let body = null;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    body = text;
+  }
+  return { status: res.status, body };
+}
+
+/* ── MediaInfo ────────────────────────────────────────────────────────────── */
+//
+// Le format est celui de MediaInfo, pas un résumé maison : c'est ce que
+// `parseMediaInfoText()` sait relire (`^(General|Video|Audio|Text)\s*#?\d*$`
+// puis des lignes `clé : valeur`). Un libellé inventé est ignoré en silence.
+
+const mi = (blocks) =>
+  blocks
+    .map(([title, rows]) =>
+      [title, ...rows.filter(([, v]) => v).map(([k, v]) => `${k.padEnd(40)}: ${v}`)].join('\n'),
+    )
+    .join('\n\n');
+
+/* ── Les fixtures ─────────────────────────────────────────────────────────── */
+
+const DUNE_ROOT =
+  'Dune.Part.Two.2024.2160p.UHD.BluRay.REMUX.DV.HDR.HEVC.TrueHD.7.1.Atmos-FraMeSToR';
+
+const duneFiles = [
+  { path: `${DUNE_ROOT}/${DUNE_ROOT}.mkv`, length: 88_412_913_664 },
+  { path: `${DUNE_ROOT}/FraMeSToR.nfo`, length: 12_284 },
+  { path: `${DUNE_ROOT}/Sample/sample.mkv`, length: 214_958_080 },
+];
+
+const duneNfo = mi([
+  ['General', [
+    ['Complete name', `${DUNE_ROOT}.mkv`],
+    ['Format', 'Matroska'],
+    ['File size', '82.3 GiB'],
+    ['Duration', '2 h 46 min'],
+    ['Overall bit rate', '70.9 Mb/s'],
+  ]],
+  ['Video', [
+    ['Format', 'HEVC'],
+    ['Format profile', 'Main 10@L5.1@High'],
+    ['Width', '3 840 pixels'],
+    ['Height', '2 160 pixels'],
+    ['Frame rate', '23.976 FPS'],
+    ['Bit depth', '10 bits'],
+    ['Bit rate', '61.5 Mb/s'],
+    ['Writing library', 'x265'],
+    ['Language', 'English'],
+    ['Default', 'Yes'],
+    ['Forced', 'No'],
+  ]],
+  ['Audio #1', [
+    ['Format', 'MLP FBA 16-ch'],
+    ['Commercial name', 'Dolby TrueHD with Dolby Atmos'],
+    ['Channel(s)', '8 channels'],
+    ['Bit rate', '4 448 kb/s'],
+    ['Language', 'English'],
+    ['Title', 'TrueHD 7.1 Atmos'],
+    ['Default', 'Yes'],
+    ['Forced', 'No'],
+  ]],
+  ['Audio #2', [
+    ['Format', 'DTS'],
+    ['Commercial name', 'DTS-HD Master Audio'],
+    ['Channel(s)', '6 channels'],
+    ['Bit rate', '3 018 kb/s'],
+    ['Language', 'French'],
+    ['Title', 'VFF DTS-HD MA 5.1'],
+    ['Default', 'No'],
+    ['Forced', 'No'],
+  ]],
+  ['Audio #3', [
+    ['Format', 'E-AC-3'],
+    ['Commercial name', 'Dolby Digital Plus'],
+    ['Channel(s)', '6 channels'],
+    ['Bit rate', '640 kb/s'],
+    ['Language', 'Spanish'],
+    ['Title', 'Castellano DD+ 5.1'],
+    ['Default', 'No'],
+    ['Forced', 'No'],
+  ]],
+  ['Text #1', [
+    ['Format', 'UTF-8'],
+    ['Language', 'French'],
+    ['Title', 'VFF complet'],
+    ['Default', 'Yes'],
+    ['Forced', 'No'],
+  ]],
+  ['Text #2', [
+    ['Format', 'UTF-8'],
+    ['Language', 'French'],
+    ['Title', 'VFF forces'],
+    ['Default', 'No'],
+    ['Forced', 'Yes'],
+  ]],
+  ['Text #3', [
+    ['Format', 'PGS'],
+    ['Language', 'English'],
+    ['Title', 'English SDH'],
+    ['Default', 'No'],
+    ['Forced', 'No'],
+    ['Hearing impaired', 'Yes'],
+  ]],
+  ['Text #4', [
+    ['Format', 'PGS'],
+    ['Language', 'Spanish'],
+    ['Default', 'No'],
+    ['Forced', 'No'],
+  ]],
+  ['Text #5', [
+    ['Format', 'PGS'],
+    ['Language', 'Japanese'],
+    ['Default', 'No'],
+    ['Forced', 'No'],
+  ]],
+]);
+
+const duneDescription = `[center][b]DUNE : DEUXIÈME PARTIE[/b] — 2024 — Denis Villeneuve[/center]
+
+[quote]Paul Atreides s'unit à Chani et aux Fremen pour mener la révolte contre ceux qui ont détruit sa famille.[/quote]
+
+[b]Source[/b] : UHD BluRay FR (Warner) — remux intégral, aucun réencodage.
+[b]Vidéo[/b] : HEVC 10 bits, Dolby Vision Profile 7 avec repli HDR10, grain préservé.
+[b]Audio[/b] : la piste anglaise est la TrueHD 7.1 Atmos d'origine. La VFF est la DTS-HD MA 5.1 du disque français, non recompressée.
+[b]Sous-titres[/b] : VFF complets et forcés, anglais SDH, espagnol, japonais.
+
+[b]Notes[/b]
+[list]
+[*]Les chapitres du disque sont conservés.
+[*]Le dossier [i]Sample[/i] contient 90 s tirées de l'arrivée sur Arrakeen.
+[*]Merci de rester en seed : c'est 82 Gio, personne ne les récupère en une heure.
+[/list]`;
+
+const BEAR_ROOT = 'The.Bear.S03.1080p.WEB-DL.DDP5.1.H.264-NTb';
+const bearFiles = Array.from({ length: 10 }, (_, i) => ({
+  path: `${BEAR_ROOT}/The.Bear.S03E${String(i + 1).padStart(2, '0')}.1080p.WEB-DL.DDP5.1.H.264-NTb.mkv`,
+  length: 1_932_735_283 + i * 41_231_686,
+}));
+
+const bearNfo = mi([
+  ['General', [
+    ['Complete name', 'The.Bear.S03E01.1080p.WEB-DL.DDP5.1.H.264-NTb.mkv'],
+    ['Format', 'Matroska'],
+    ['File size', '1.80 GiB'],
+    ['Duration', '32 min 4 s'],
+    ['Overall bit rate', '8 043 kb/s'],
+  ]],
+  ['Video', [
+    ['Format', 'AVC'],
+    ['Format profile', 'High@L4'],
+    ['Width', '1 920 pixels'],
+    ['Height', '1 080 pixels'],
+    ['Frame rate', '23.976 FPS'],
+    ['Bit depth', '8 bits'],
+    ['Bit rate', '7 464 kb/s'],
+    ['Language', 'English'],
+  ]],
+  ['Audio #1', [
+    ['Format', 'E-AC-3'],
+    ['Commercial name', 'Dolby Digital Plus'],
+    ['Channel(s)', '6 channels'],
+    ['Bit rate', '640 kb/s'],
+    ['Language', 'English'],
+    ['Default', 'Yes'],
+  ]],
+  ['Audio #2', [
+    ['Format', 'E-AC-3'],
+    ['Channel(s)', '6 channels'],
+    ['Bit rate', '640 kb/s'],
+    ['Language', 'French'],
+    ['Title', 'VF Québec'],
+    ['Default', 'No'],
+  ]],
+  ['Text #1', [
+    ['Format', 'UTF-8'],
+    ['Language', 'French'],
+    ['Default', 'Yes'],
+  ]],
+  ['Text #2', [
+    ['Format', 'UTF-8'],
+    ['Language', 'English'],
+    ['Title', 'English SDH'],
+    ['Hearing impaired', 'Yes'],
+  ]],
+]);
+
+const FLAC_ROOT = 'Radiohead - In Rainbows (2007) [FLAC 24-96]';
+const flacFiles = [
+  ...Array.from({ length: 10 }, (_, i) => ({
+    path: `${FLAC_ROOT}/${String(i + 1).padStart(2, '0')} - Track ${i + 1}.flac`,
+    length: 68_157_440 + i * 5_242_880,
+  })),
+  { path: `${FLAC_ROOT}/cover.jpg`, length: 2_411_724 },
+  { path: `${FLAC_ROOT}/In Rainbows.log`, length: 8_432 },
+];
+
+const flacNfo = mi([
+  ['General', [
+    ['Complete name', '01 - 15 Step.flac'],
+    ['Format', 'FLAC'],
+    ['File size', '65.0 MiB'],
+    ['Duration', '3 min 57 s'],
+    ['Overall bit rate', '2 298 kb/s'],
+  ]],
+  ['Audio', [
+    ['Format', 'FLAC'],
+    ['Channel(s)', '2 channels'],
+    ['Bit rate', '2 298 kb/s'],
+    ['Language', 'English'],
+    ['Title', 'Vinyl rip 24 bits / 96 kHz'],
+    ['Default', 'Yes'],
+  ]],
+]);
+
+const GAME_ROOT = "Baldur's Gate 3 v4.1.1.4667176 (GOG)";
+
+/**
+ * Ce que ce script dépose.
+ *
+ * `tmdbId` sert au regroupement de la page (`tmdb:693134` pour les quatre
+ * éditions du film) — c'est la seule façon de voir la table des versions
+ * autrement que vide.
+ */
+const RELEASES = [
+  {
+    key: 'dune4k',
+    who: 'founder',
+    category: 'films',
+    name: DUNE_ROOT,
+    files: duneFiles,
+    nfo: duneNfo,
+    description: duneDescription,
+    tmdbId: '693134',
+    imdbId: 'tt15239678',
+    tags: 'remux, dolby-vision, atmos, vff, science-fiction',
+  },
+  {
+    // Le cross-seed : MÊME liste de fichiers, `piece length` de 8 Mio au lieu
+    // de 4 — donc même `content_signature`, info_hash différent. Le nom
+    // affiché diffère (c'est le champ `name` du formulaire, pas celui du
+    // .torrent), comme quand la même release circule sous deux conventions.
+    key: 'dune4kXseed',
+    who: 'donator',
+    category: 'films',
+    name: `${DUNE_ROOT} [pieces 8MiB]`,
+    torrentName: DUNE_ROOT,
+    files: duneFiles,
+    pieceLength: 8 * 1024 * 1024,
+    nfo: duneNfo,
+    description: `Cross-seed du remux FraMeSToR — contenu identique, découpage en pièces de 8 Mio.
+
+Utile si votre client refuse de re-vérifier 82 Gio pour la version 4 Mio.`,
+    tmdbId: '693134',
+    tags: 'remux, cross-seed, dolby-vision',
+  },
+  {
+    key: 'dune1080',
+    who: 'donator',
+    category: 'films',
+    name: 'Dune.Part.Two.2024.1080p.BluRay.x264.DTS-HD.MA.5.1-SbR',
+    files: [
+      {
+        path: 'Dune.Part.Two.2024.1080p.BluRay.x264.DTS-HD.MA.5.1-SbR/Dune.Part.Two.2024.1080p.BluRay.x264.DTS-HD.MA.5.1-SbR.mkv',
+        length: 18_253_611_008,
+      },
+      { path: 'Dune.Part.Two.2024.1080p.BluRay.x264.DTS-HD.MA.5.1-SbR/sbr.nfo', length: 4_096 },
+    ],
+    description: `L'édition 1080p, pour qui n'a pas 82 Gio à donner au film.
+
+[b]Remplacée[/b] par le PROPER : la VFF de cette version est désynchronisée d'environ 400 ms à partir du chapitre 12.`,
+    tmdbId: '693134',
+    tags: 'x264, vff, science-fiction',
+  },
+  {
+    key: 'dune1080proper',
+    who: 'founder',
+    category: 'films',
+    name: 'Dune.Part.Two.2024.PROPER.1080p.BluRay.x264.DTS-HD.MA.5.1-SbR',
+    files: [
+      {
+        path: 'Dune.Part.Two.2024.PROPER.1080p.BluRay.x264.DTS-HD.MA.5.1-SbR/Dune.Part.Two.2024.PROPER.1080p.BluRay.x264.DTS-HD.MA.5.1-SbR.mkv',
+        length: 18_254_659_584,
+      },
+      {
+        path: 'Dune.Part.Two.2024.PROPER.1080p.BluRay.x264.DTS-HD.MA.5.1-SbR/sbr.nfo',
+        length: 4_112,
+      },
+    ],
+    description:
+      'PROPER : la piste VFF est resynchronisée. Le reste est identique bit pour bit.',
+    tmdbId: '693134',
+    tags: 'x264, proper, vff',
+  },
+  {
+    key: 'bear',
+    who: 'founder',
+    category: 'series',
+    name: BEAR_ROOT,
+    files: bearFiles,
+    nfo: bearNfo,
+    description: `[b]The Bear[/b] — saison 3 complète, 10 épisodes, WEB-DL Disney+ FR.
+
+[list]
+[*]Piste anglaise DDP 5.1 d'origine.
+[*]VF québécoise incluse, même débit.
+[*]Sous-titres français et anglais SDH, extraits du flux, non OCR.
+[/list]
+
+[b]Upload ×2 jusqu'à dimanche[/b] — la saison 4 sort la semaine suivante et l'essaim va se vider.`,
+    tvdbId: '387662',
+    tags: 'web-dl, saison-complete, vf, comedie',
+  },
+  {
+    key: 'flac',
+    who: 'donator',
+    category: 'musique',
+    name: 'Radiohead - In Rainbows (2007) [FLAC 24-96 Vinyl]',
+    torrentName: FLAC_ROOT,
+    files: flacFiles,
+    nfo: flacNfo,
+    description: `Rip vinyle 24 bits / 96 kHz, platine Technics SL-1200GR + Ortofon 2M Black.
+
+[b]Chaîne[/b] : préampli Rega Fono MM → RME ADI-2 Pro → FLAC niveau 8, sans normalisation ni declic automatique.
+[b]Log[/b] : inclus dans le dossier.
+
+Le pressage 2016 (XLLP 2007) — pas la réédition 2021, qui est un report du CD.`,
+    tags: 'flac, 24bit, vinyle, rock',
+  },
+  {
+    key: 'game',
+    who: 'founder',
+    category: 'jeux',
+    name: "Baldur's Gate 3 v4.1.1.4667176 (GOG) + All DLCs",
+    torrentName: GAME_ROOT,
+    files: [
+      {
+        path: `${GAME_ROOT}/setup_baldurs_gate_3_4.1.1.4667176_(64bit)_(78334).exe`,
+        length: 4_294_967_296,
+      },
+      ...Array.from({ length: 27 }, (_, i) => ({
+        path: `${GAME_ROOT}/setup_baldurs_gate_3_4.1.1.4667176_(64bit)_(78334)-${i + 1}.bin`,
+        length: 4_294_967_296,
+      })),
+    ],
+    description: `Installeur GOG hors-ligne, patch 8 (v4.1.1.4667176). Aucun crack : la version GOG n'a pas de DRM.
+
+[b]Contenu[/b] : jeu de base + Digital Deluxe Edition DLC.
+[b]Langues[/b] : toutes celles du dépôt GOG, dont la VF intégrale (textes et voix).
+[b]Installation[/b] : lancer le [i].exe[/i], les [i].bin[/i] sont lus automatiquement.`,
+    tags: 'gog, drm-free, rpg, vf',
+  },
+  {
+    key: 'ebook',
+    who: 'plainuser',
+    category: 'livres',
+    name: 'Frank Herbert - Le Cycle de Dune (6 tomes) [EPUB]',
+    torrentName: 'Frank Herbert - Le Cycle de Dune',
+    files: Array.from({ length: 6 }, (_, i) => ({
+      path: `Frank Herbert - Le Cycle de Dune/Tome ${i + 1}.epub`,
+      length: 1_048_576 + i * 262_144,
+    })),
+    description: `Les six romans de Frank Herbert, traduction Michel Demuth revue (Robert Laffont, collection Ailleurs & Demain).
+
+EPUB 3, sans DRM, table des matières et notes de bas de page conservées.`,
+    tags: 'epub, science-fiction, vf',
+    // Personne n'annonce : c'est le torrent sans seeder, qui fait apparaître
+    // la demande de reseed sur la page.
+    noSwarm: true,
+  },
+  {
+    key: 'pending',
+    who: 'plainuser',
+    category: 'films',
+    name: 'Sicario.2015.1080p.BluRay.x265.10bit.AAC5.1-YOLO',
+    files: [
+      {
+        path: 'Sicario.2015.1080p.BluRay.x265.10bit.AAC5.1-YOLO/Sicario.2015.1080p.x265-YOLO.mkv',
+        length: 2_147_483_648,
+      },
+    ],
+    description: 'Encodage maison x265, CRF 20, preset slow. Audio en AAC 5.1 à 448 kb/s.',
+    tmdbId: '242582',
+    tags: 'x265, encodage-maison',
+    // Laissé en attente : c'est ce qui rend visible le bandeau de modération
+    // sur la page, pour son auteur et pour le personnel.
+    keepPending: true,
+    noSwarm: true,
+  },
+  {
+    key: 'adult',
+    who: 'founder',
+    category: 'adulte',
+    name: 'E2E.Adult.Fixture.2024.1080p.WEB-DL.x264-DEMO',
+    files: [
+      {
+        path: 'E2E.Adult.Fixture.2024.1080p.WEB-DL.x264-DEMO/fixture.mkv',
+        length: 3_221_225_472,
+      },
+    ],
+    description:
+      "Fixture de catégorie adulte. Elle n'existe que pour vérifier le voile de la page de détail et le réglage « afficher le contenu adulte ».",
+    tags: 'web-dl',
+  },
+
+  /* ── Les VERSIONS d'une même unité ────────────────────────────────────────
+   *
+   * Tout ce qui précède est une release par œuvre, ou presque : la question
+   * « laquelle de ces six je prends ? » ne se posait qu'au niveau du film. Or
+   * c'est au niveau de l'ÉPISODE qu'elle se pose le plus souvent sur un
+   * tracker d'animation — quatre équipes sortent le même épisode le même
+   * soir, en VOSTFR, en VF, en 1080p, en 2160p.
+   *
+   * Les neuf entrées ci-dessous couvrent les trois portées que
+   * `/api/torrents/group` sait distinguer, sous un seul `tmdbId` :
+   *
+   *   - portée `episode`  : E09 en quatre versions, E10 en deux
+   *   - portée `season`   : la saison complète en deux versions
+   *   - portée `integral` : un pack sans numéro de saison
+   *
+   * `season` et `episode` ne sont PAS des champs du formulaire : ils sont
+   * analysés depuis le nom de release par `parseReleaseName` (le motif
+   * `SxxExx`). D'où des noms scrupuleusement conformes — un nom approximatif
+   * ne produit pas une release mal rangée, il produit une release SANS unité,
+   * donc invisible dans toutes les vues par portée.
+   * ────────────────────────────────────────────────────────────────────── */
+
+  {
+    key: 'frierenE09a',
+    who: 'founder',
+    category: 'series',
+    name: 'Sousou.no.Frieren.S01E09.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws',
+    files: [
+      {
+        path: 'Sousou.no.Frieren.S01E09.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws.mkv',
+        length: 1_476_395_008,
+      },
+    ],
+    nfo: mi([
+      ['General', [
+        ['Complete name', 'Sousou.no.Frieren.S01E09.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws.mkv'],
+        ['Format', 'Matroska'],
+        ['File size', '1.38 GiB'],
+        ['Duration', '23 min 40 s'],
+        ['Overall bit rate', '8 312 kb/s'],
+      ]],
+      ['Video', [
+        ['Format', 'AVC'],
+        ['Format profile', 'High@L4'],
+        ['Width', '1 920 pixels'],
+        ['Height', '1 080 pixels'],
+        ['Frame rate', '23.976 FPS'],
+        ['Bit depth', '8 bits'],
+        ['Bit rate', '8 000 kb/s'],
+        ['Language', 'Japanese'],
+      ]],
+      ['Audio', [
+        ['Format', 'AAC'],
+        ['Channel(s)', '2 channels'],
+        ['Bit rate', '192 kb/s'],
+        ['Language', 'Japanese'],
+        ['Default', 'Yes'],
+      ]],
+      ['Text', [
+        ['Format', 'ASS'],
+        ['Language', 'French'],
+        ['Title', 'VOSTFR'],
+        ['Default', 'Yes'],
+      ]],
+    ]),
+    description: `Épisode 09 — sortie du soir, source Crunchyroll FR.
+
+Sous-titres ASS avec styles et karaoké sur l'opening. Aucun réencodage vidéo.`,
+    tmdbId: 'tv/209867',
+    tags: 'web-dl, vostfr, anime',
+  },
+  {
+    key: 'frierenE09b',
+    who: 'donator',
+    category: 'series',
+    name: 'Sousou.no.Frieren.S01E09.VOSTFR.1080p.WEBRip.AAC.2.0.x265-NOTAG',
+    files: [
+      {
+        path: 'Sousou.no.Frieren.S01E09.VOSTFR.1080p.WEBRip.AAC.2.0.x265-NOTAG.mkv',
+        length: 734_003_200,
+      },
+    ],
+    description: `Réencodage x265 du même épisode : la moitié du poids pour un œil non exercé.
+
+À prendre si vous archivez la saison entière et que 24 × 1,4 Gio ne passe pas.`,
+    tmdbId: 'tv/209867',
+    tags: 'webrip, x265, vostfr, anime',
+  },
+  {
+    key: 'frierenE09c',
+    who: 'founder',
+    category: 'series',
+    name: 'Sousou.no.Frieren.S01E09.MULTi.2160p.WEB-DL.DDP5.1.HDR.HEVC-FLUX',
+    files: [
+      {
+        path: 'Sousou.no.Frieren.S01E09.MULTi.2160p.WEB-DL.DDP5.1.HDR.HEVC-FLUX.mkv',
+        length: 4_509_715_660,
+      },
+    ],
+    description: `L'épisode 09 en 2160p HDR10, pistes japonaise et française, DDP 5.1.
+
+Le seul upscale du lot est celui de la plateforme elle-même — la source n'existe pas en 4K natif.`,
+    tmdbId: 'tv/209867',
+    tags: 'web-dl, hdr, multi, anime',
+  },
+  {
+    key: 'frierenE09d',
+    who: 'donator',
+    category: 'series',
+    name: 'Sousou.no.Frieren.S01E09.VF.1080p.WEB-DL.EAC3.2.0.H.264-QCTeam',
+    files: [
+      {
+        path: 'Sousou.no.Frieren.S01E09.VF.1080p.WEB-DL.EAC3.2.0.H.264-QCTeam.mkv',
+        length: 1_395_864_371,
+      },
+    ],
+    description: 'Version française uniquement, doublage québécois. Aucun sous-titre.',
+    tmdbId: 'tv/209867',
+    tags: 'web-dl, vf, anime',
+  },
+  {
+    key: 'frierenE10a',
+    who: 'founder',
+    category: 'series',
+    name: 'Sousou.no.Frieren.S01E10.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws',
+    files: [
+      {
+        path: 'Sousou.no.Frieren.S01E10.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws.mkv',
+        length: 1_503_238_553,
+      },
+    ],
+    description: 'Épisode 10, même chaîne de traitement que le 09.',
+    tmdbId: 'tv/209867',
+    tags: 'web-dl, vostfr, anime',
+  },
+  {
+    key: 'frierenE10b',
+    who: 'donator',
+    category: 'series',
+    name: 'Sousou.no.Frieren.S01E10.MULTi.1080p.WEB-DL.DDP2.0.H.264-VARYG',
+    files: [
+      {
+        path: 'Sousou.no.Frieren.S01E10.MULTi.1080p.WEB-DL.DDP2.0.H.264-VARYG.mkv',
+        length: 1_610_612_736,
+      },
+    ],
+    description: 'Épisode 10 bilingue, pistes japonaise et française dans le même fichier.',
+    tmdbId: 'tv/209867',
+    tags: 'web-dl, multi, anime',
+  },
+  {
+    key: 'frierenS01a',
+    who: 'founder',
+    category: 'series',
+    name: 'Sousou.no.Frieren.S01.MULTi.1080p.BluRay.x265.10bit.FLAC.2.0-KAWAII',
+    torrentName: 'Sousou.no.Frieren.S01.MULTi.1080p.BluRay.x265.10bit.FLAC.2.0-KAWAII',
+    files: Array.from({ length: 28 }, (_, i) => ({
+      path: `Sousou.no.Frieren.S01.MULTi.1080p.BluRay.x265.10bit.FLAC.2.0-KAWAII/Sousou.no.Frieren.S01E${String(i + 1).padStart(2, '0')}.MULTi.1080p.BluRay.x265.10bit.FLAC.2.0-KAWAII.mkv`,
+      length: 687_194_767 + i * 8_388_608,
+    })),
+    description: `[b]Saison 1 complète[/b] — 28 épisodes, source BluRay japonais.
+
+[list]
+[*]Encodage x265 10 bits, CRF 18, grain préservé.
+[*]Pistes japonaise FLAC 2.0 et française EAC3 2.0.
+[*]Sous-titres VOSTFR et VF forcés.
+[/list]`,
+    tmdbId: 'tv/209867',
+    tags: 'bluray, x265, multi, saison-complete, anime',
+  },
+  {
+    key: 'frierenS01b',
+    who: 'donator',
+    category: 'series',
+    name: 'Sousou.no.Frieren.S01.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws',
+    torrentName: 'Sousou.no.Frieren.S01.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws',
+    files: Array.from({ length: 28 }, (_, i) => ({
+      path: `Sousou.no.Frieren.S01.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws/Sousou.no.Frieren.S01E${String(i + 1).padStart(2, '0')}.VOSTFR.1080p.WEB-DL.AAC.2.0.H.264-TsundereRaws.mkv`,
+      length: 1_476_395_008 + i * 4_194_304,
+    })),
+    description: `Le pack des sorties hebdomadaires, sans réencodage. Plus lourd que la version BluRay et sorti six mois plus tôt.`,
+    tmdbId: 'tv/209867',
+    tags: 'web-dl, vostfr, saison-complete, anime',
+  },
+  {
+    // Sans numéro de saison dans le nom : `parseReleaseName` ne trouve rien,
+    // donc `season` reste NULL et la release tombe dans la portée `integral`.
+    // C'est le cas qui rend cette portée visible.
+    key: 'frierenIntegral',
+    who: 'founder',
+    category: 'series',
+    name: 'Sousou no Frieren - Integrale MULTi 1080p BluRay x265 10bit FLAC-KAWAII',
+    torrentName: 'Sousou no Frieren - Integrale',
+    files: Array.from({ length: 28 }, (_, i) => ({
+      path: `Sousou no Frieren - Integrale/Frieren - ${String(i + 1).padStart(2, '0')}.mkv`,
+      length: 687_194_767 + i * 8_388_608,
+    })),
+    description: `L'intégrale en un seul torrent, épisodes renommés sans convention de scène — le pack « je veux tout et je m'en fous du nommage ».`,
+    tmdbId: 'tv/209867',
+    tags: 'bluray, x265, multi, anime',
+  },
+];
+
+const CATEGORIES = [
+  { key: 'films', name: 'Films', isAdult: false },
+  { key: 'series', name: 'Séries', isAdult: false },
+  { key: 'musique', name: 'Musique', isAdult: false },
+  { key: 'jeux', name: 'Jeux', isAdult: false },
+  { key: 'livres', name: 'Livres', isAdult: false },
+  { key: 'adulte', name: 'XXX', isAdult: true },
+];
+
+/* ── Les comptes de l'essaim ──────────────────────────────────────────────── */
+//
+// Un pair est rattaché au membre dont la passkey a servi à l'annonce. Avec les
+// trois comptes du seed, un essaim plafonne à trois lignes. Quatre membres de
+// plus, inscrits par le VRAI chemin, suffisent à ce qu'un essaim ressemble à
+// un essaim.
+//
+// Le cache disque évite de repayer la preuve de travail à chaque relance.
+
+const SWARM_ACCOUNTS = [
+  { username: 'mando', email: 'mando@e2e.test', password: 'E2e-Passw0rd!mando' },
+  { username: 'shai_hulud', email: 'shai@e2e.test', password: 'E2e-Passw0rd!shai' },
+  { username: 'harkonnen', email: 'harko@e2e.test', password: 'E2e-Passw0rd!harko' },
+  { username: 'bene_gesserit', email: 'bene@e2e.test', password: 'E2e-Passw0rd!bene' },
+];
+
+const CACHE = new URL('session-torrents.json', HERE);
+
+async function pow() {
+  const { body } = await call('/api/auth/pow');
+  return solvePoW(body.challenge, body.difficulty, undefined, 240_000);
+}
+
+async function register(acc) {
+  const jar = jarFor(acc.username);
+  const creds = await generateCredentials(acc.password);
+  const solved = await pow();
+  return call('/api/auth/register', {
+    method: 'POST',
+    jar,
+    body: {
+      username: acc.username,
+      email: acc.email,
+      password: acc.password,
+      confirmPassword: acc.password,
+      authSalt: creds.salt,
+      authVerifier: creds.verifier,
+      powChallenge: solved.challenge,
+      powNonce: solved.nonce,
+      powHash: solved.hash,
+    },
+  });
+}
+
+async function login(acc) {
+  const jar = jarFor(acc.username);
+  jar.clear();
+  const chal = await call(`/api/auth/challenge?username=${encodeURIComponent(acc.username)}`, {
+    jar,
+  });
+  if (!ok(chal.status)) return chal;
+  const proof = await generateLoginProof(acc.password, chal.body.salt, chal.body.challenge);
+  return call('/api/auth/login', {
+    method: 'POST',
+    jar,
+    body: { username: acc.username, challenge: chal.body.challenge, proof },
+  });
+}
+
+async function ensureSwarmAccounts() {
+  const cached = existsSync(CACHE) ? JSON.parse(readFileSync(CACHE, 'utf8')) : {};
+
+  // L'inscription se ferme derrière le premier compte enregistré ; le seed l'a
+  // rouverte, mais un scénario peut l'avoir refermée depuis.
+  await call('/api/admin/settings', {
+    method: 'PUT',
+    who: 'founder',
+    body: { registrationOpen: true },
+  });
+
+  const out = {};
+  for (const acc of SWARM_ACCOUNTS) {
+    if (cached[acc.username]?.cookie) {
+      // Le cookie du cache peut appartenir à une pile précédente, détruite
+      // depuis : la seule preuve qu'il vaut encore est de s'en servir.
+      const jar = jarFor(acc.username);
+      jar.clear();
+      for (const pair of cached[acc.username].cookie.split('; ')) {
+        const i = pair.indexOf('=');
+        if (i > 0) jar.set(pair.slice(0, i), pair.slice(i + 1));
+      }
+      const who = await call('/api/auth/status', { jar });
+      if (who.body?.user?.id) {
+        out[acc.username] = { ...cached[acc.username], id: who.body.user.id };
+        step(`${acc.username} (cache)`, true);
+        continue;
+      }
+      jar.clear();
+    }
+
+    await sleep(2500);
+    let r = await register(acc);
+    let via = 'register';
+    if (!ok(r.status)) {
+      r = await login(acc);
+      via = 'login';
+    }
+    if (!ok(r.status)) {
+      step(acc.username, false, `${r.status} ${JSON.stringify(r.body).slice(0, 120)}`);
+      continue;
+    }
+    const jar = jarFor(acc.username);
+    const who = await call('/api/auth/status', { jar });
+    out[acc.username] = { cookie: cookieHeader(jar), via, id: who.body?.user?.id ?? null };
+    step(`${acc.username} (${via})`, true);
+  }
+  writeFileSync(CACHE, JSON.stringify(out, null, 2));
+  return out;
+}
+
+/* ── L'essaim ─────────────────────────────────────────────────────────────── */
+
+/** La passkey d'annonce d'un membre, par le même appel que la page /me. */
+async function passkeyOf(who) {
+  const { status, body } = await call('/api/auth/passkey', { who });
+  return ok(status) ? (body?.passkey ?? null) : null;
+}
+
+/* ── Le programme ─────────────────────────────────────────────────────────── */
+
+async function main() {
+  if (!S.founder?.cookie) {
+    console.error('session.json ne porte pas de founder — lancer run.sh --keep d’abord.');
+    process.exit(1);
+  }
+
+  console.log('\n1. catégories');
+  await resetRateLimits().catch(() => {});
+  const catId = {};
+  for (const c of CATEGORIES) {
+    const made = await call('/api/admin/categories', {
+      method: 'POST',
+      who: 'founder',
+      body: { name: c.name, isAdult: c.isAdult },
+    });
+    let id = made.body?.id ?? made.body?.category?.id ?? made.body?.data?.id ?? null;
+    if (!id) {
+      // Déjà là (relance) : la retrouver. `includeAdult` est l'échappatoire du
+      // personnel, sans quoi la catégorie XXX est invisible même pour son auteur.
+      const { body } = await call('/api/categories?includeAdult=true', { who: 'founder' });
+      const list = Array.isArray(body) ? body : (body?.data ?? body?.categories ?? []);
+      const flat = list.flatMap((x) => [x, ...(x.subcategories ?? [])]);
+      id = flat.find((x) => x.name === c.name)?.id ?? null;
+    }
+    catId[c.key] = id;
+    step(c.name, !!id, id ? '' : JSON.stringify(made.body).slice(0, 120));
+  }
+
+  console.log('\n2. comptes de l’essaim');
+  const swarmAccounts = await ensureSwarmAccounts();
+
+  console.log('\n3. uploads');
+  await resetRateLimits().catch(() => {});
+  const rows = {};
+  for (const r of RELEASES) {
+    const bytes = torrentFile({
+      name: r.torrentName ?? r.name,
+      files: r.files,
+      pieceLength: r.pieceLength,
+    });
+    const res = await upload(
+      r.who,
+      {
+        name: r.name,
+        categoryId: catId[r.category],
+        description: r.description,
+        nfo: r.nfo,
+        tags: r.tags,
+        tmdbId: r.tmdbId,
+        imdbId: r.imdbId,
+        tvdbId: r.tvdbId,
+      },
+      bytes,
+    );
+    const row = res.body?.data ?? res.body?.torrent ?? res.body;
+    const hash = row?.infoHash ?? null;
+    if (hash) {
+      rows[r.key] = { ...r, infoHash: hash, size: r.files.reduce((n, f) => n + f.length, 0) };
+      step(r.name.slice(0, 60), true, hash.slice(0, 12));
+    } else {
+      step(r.name.slice(0, 60), false, `${res.status} ${JSON.stringify(res.body).slice(0, 160)}`);
+    }
+    await sleep(400);
+  }
+
+  console.log('\n4. modération');
+  for (const r of Object.values(rows)) {
+    if (r.keepPending) {
+      step(`${r.key} laissé en attente`, true, 'bandeau de modération');
+      continue;
+    }
+    // Un upload du personnel contourne déjà la modération ; approuver un
+    // torrent déjà accepté n'est pas une erreur pour cette route.
+    const res = await call(`/api/mod/torrents/${r.infoHash}/approve`, {
+      method: 'POST',
+      who: 'founder',
+    });
+    step(`${r.key} accepté`, ok(res.status) || res.status === 409, String(res.status));
+    await sleep(200);
+  }
+
+  console.log('\n5. supersession, buffs, épinglage');
+  if (rows.dune1080 && rows.dune1080proper) {
+    const res = await call(`/api/mod/torrents/${rows.dune1080.infoHash}/supersede`, {
+      method: 'PUT',
+      who: 'founder',
+      body: {
+        supersededById: rows.dune1080proper.infoHash,
+        reason: 'VFF désynchronisée d’environ 400 ms à partir du chapitre 12.',
+      },
+    });
+    step('le 1080p est remplacé par le PROPER', ok(res.status), String(res.status));
+  }
+  if (rows.dune4k) {
+    const until = new Date(Date.now() + 7 * 86_400_000).toISOString();
+    const res = await call(`/api/mod/torrents/${rows.dune4k.infoHash}/buffs`, {
+      method: 'PUT',
+      who: 'founder',
+      body: { downloadMultiplier: 0, uploadMultiplier: 100, until, isSticky: true },
+    });
+    step('freeleech 7 jours + épinglage sur le remux', ok(res.status), String(res.status));
+  }
+  if (rows.bear) {
+    const res = await call(`/api/mod/torrents/${rows.bear.infoHash}/buffs`, {
+      method: 'PUT',
+      who: 'founder',
+      body: { uploadMultiplier: 200, until: new Date(Date.now() + 3 * 86_400_000).toISOString() },
+    });
+    step('upload ×2 sur The Bear S03', ok(res.status), String(res.status));
+  }
+
+  console.log('\n6. commentaires');
+  const COMMENTS = [
+    [
+      'dune4k',
+      'donator',
+      'Le meilleur remux du film à ce jour. La VFF est bien celle du disque français, pas un upmix.',
+    ],
+    [
+      'dune4k',
+      'plainuser',
+      'Question bête : mon téléviseur ne fait que du HDR10, est-ce que le Dolby Vision Profile 7 se replie correctement ?',
+    ],
+    [
+      'dune4k',
+      'founder',
+      '[quote=plainuser]est-ce que le Dolby Vision Profile 7 se replie correctement ?[/quote]\nOui — le profil 7 embarque la couche HDR10 de base. Ton téléviseur lira le HDR10 et ignorera la couche RPU.',
+    ],
+    ['dune4k', 'mando', 'En seed depuis ce matin, 82 Gio à 1,2 Gio/s en pointe. Merci pour le freeleech.'],
+    [
+      'dune1080',
+      'plainuser',
+      'Le décalage de la VFF est franchement audible à partir de la scène du ver. Prenez le PROPER.',
+    ],
+    ['bear', 'harkonnen', 'La VF québécoise est un vrai plus, on ne la trouve nulle part ailleurs.'],
+    ['flac', 'bene_gesserit', 'Le log est propre et le rip ne montre aucun declic. Beau travail.'],
+    [
+      'game',
+      'shai_hulud',
+      '27 fichiers .bin, prévoyez la place : il faut ~120 Gio pour l’archive plus l’installation.',
+    ],
+  ];
+  for (const [key, who, content] of COMMENTS) {
+    const r = rows[key];
+    if (!r) continue;
+    if (!S[who] && !swarmAccounts[who]) continue;
+    const res = await call(`/api/torrents/${r.infoHash}/comments`, {
+      method: 'POST',
+      who,
+      body: { content },
+    });
+    step(`${who} sur ${key}`, ok(res.status), String(res.status));
+    await sleep(250);
+  }
+
+  console.log('\n7. favoris et obligation de seed');
+  if (rows.dune4k) {
+    for (const who of ['plainuser', 'donator']) {
+      const res = await call(`/api/torrents/${rows.dune4k.infoHash}/favorite`, {
+        method: 'POST',
+        who,
+      });
+      step(`${who} met le remux en favori`, ok(res.status) || res.status === 409, String(res.status));
+    }
+    // Le clic sur le .torrent est ce qui pose la ligne `hnr_tracking`. Sans
+    // lui, l'annonce qui suit n'a rien à compléter et la carte d'obligation
+    // reste absente — c'est le chemin réel, pas un raccourci.
+    const dl = await call(`/api/torrents/${rows.dune4k.infoHash}/download`, {
+      who: 'plainuser',
+      raw: true,
+    });
+    step('plainuser récupère le .torrent', ok(dl.status), `${dl.buffer?.length ?? 0} octets`);
+  }
+
+  console.log('\n8. essaim (annonces réelles)');
+  const passkeys = {};
+  for (const who of ['founder', 'donator', 'plainuser', ...Object.keys(swarmAccounts)]) {
+    const pk = await passkeyOf(who);
+    if (pk) passkeys[who] = pk;
+  }
+  step('passkeys récupérées', Object.keys(passkeys).length > 0, Object.keys(passkeys).join(' '));
+
+  const GiB = 1024 ** 3;
+  // Qui est dans quel essaim, et dans quel état. `done: 1` = seeder ;
+  // `done < 1` = leecher, et le pourcentage que la page affiche vient de là.
+  const SWARM = [
+    ['dune4k', 'founder', { done: 1, up: 412 * GiB }],
+    ['dune4k', 'mando', { done: 1, up: 96 * GiB }],
+    ['dune4k', 'shai_hulud', { done: 1, up: 11 * GiB }],
+    ['dune4k', 'harkonnen', { done: 0.34, up: 2 * GiB }],
+    ['dune4k', 'bene_gesserit', { done: 0.71, up: 8 * GiB }],
+    ['dune4k', 'plainuser', { done: 1, up: 0 }],
+    ['dune4kXseed', 'donator', { done: 1, up: 4 * GiB }],
+    ['dune4kXseed', 'mando', { done: 1, up: 19 * GiB }],
+    ['dune1080', 'donator', { done: 1, up: 61 * GiB }],
+    ['dune1080', 'bene_gesserit', { done: 1, up: 3 * GiB }],
+    ['dune1080proper', 'founder', { done: 1, up: 22 * GiB }],
+    ['dune1080proper', 'mando', { done: 1, up: 7 * GiB }],
+    ['dune1080proper', 'harkonnen', { done: 0.12, up: 0 }],
+    ['bear', 'founder', { done: 1, up: 148 * GiB }],
+    ['bear', 'shai_hulud', { done: 1, up: 31 * GiB }],
+    ['bear', 'harkonnen', { done: 1, up: 12 * GiB }],
+    ['bear', 'bene_gesserit', { done: 0.88, up: 1 * GiB }],
+    ['bear', 'plainuser', { done: 0.05, up: 0 }],
+    ['flac', 'donator', { done: 1, up: 9 * GiB }],
+    ['flac', 'bene_gesserit', { done: 1, up: 2 * GiB }],
+    ['game', 'founder', { done: 1, up: 244 * GiB }],
+    ['game', 'shai_hulud', { done: 0.46, up: 0 }],
+    ['adult', 'founder', { done: 1, up: 1 * GiB }],
+    // Les versions : des essaims de tailles TRÈS différentes sur la même
+    // unité, parce que c'est ce qui départage deux versions quand la qualité
+    // ne suffit pas — le 2160p peut être meilleur et introuvable.
+    ['frierenE09a', 'founder', { done: 1, up: 31 * GiB }],
+    ['frierenE09a', 'mando', { done: 1, up: 12 * GiB }],
+    ['frierenE09a', 'shai_hulud', { done: 1, up: 4 * GiB }],
+    ['frierenE09a', 'harkonnen', { done: 0.62, up: 0 }],
+    ['frierenE09b', 'donator', { done: 1, up: 8 * GiB }],
+    ['frierenE09c', 'founder', { done: 1, up: 2 * GiB }],
+    ['frierenE09d', 'donator', { done: 1, up: 1 * GiB }],
+    ['frierenE10a', 'founder', { done: 1, up: 22 * GiB }],
+    ['frierenE10a', 'bene_gesserit', { done: 1, up: 3 * GiB }],
+    ['frierenE10b', 'donator', { done: 1, up: 5 * GiB }],
+    ['frierenS01a', 'founder', { done: 1, up: 184 * GiB }],
+    ['frierenS01a', 'mando', { done: 1, up: 41 * GiB }],
+    ['frierenS01a', 'shai_hulud', { done: 0.23, up: 0 }],
+    ['frierenS01b', 'donator', { done: 1, up: 96 * GiB }],
+    ['frierenIntegral', 'founder', { done: 1, up: 58 * GiB }],
+  ];
+
+  let announced = 0;
+  let refused = 0;
+  for (const [key, who, spec] of SWARM) {
+    const r = rows[key];
+    const pk = passkeys[who];
+    if (!r || !pk || r.noSwarm) continue;
+    const left = Math.round(r.size * (1 - spec.done));
+    const port = 6881 + (announced % 64);
+    // Deux annonces pour qui a fini : `started` puis `completed`. C'est la
+    // seconde qui incrémente le compteur de snatchs et qui ferme la ligne
+    // `hnr_tracking` — un seeder posé d'une seule annonce `started` laisse la
+    // page dire « jamais complété ».
+    const first = await announce(pk, r.infoHash, `${key}:${who}`, {
+      left: spec.done >= 1 ? r.size : left,
+      uploaded: 0,
+      downloaded: spec.done >= 1 ? 0 : r.size - left,
+      event: 'started',
+      port,
+    });
+    if (first.failure) {
+      refused += 1;
+      step(`${who} -> ${key}`, false, first.failure);
+      continue;
+    }
+    if (spec.done >= 1) {
+      await announce(pk, r.infoHash, `${key}:${who}`, {
+        left: 0,
+        uploaded: spec.up,
+        downloaded: r.size,
+        event: 'completed',
+        port,
+      });
+    }
+    announced += 1;
+    step(`${who} -> ${key}`, true, spec.done >= 1 ? 'seeder' : `${Math.round(spec.done * 100)} %`);
+    await sleep(120);
+  }
+  step('annonces', refused === 0, `${announced} acceptées, ${refused} refusées`);
+
+  // Le versement des crédits d'octets est groupé (5 s dans cette pile) : sans
+  // cette attente, les ratios affichés sont ceux d'avant les annonces.
+  console.log('\n   attente du versement des crédits (7 s)…');
+  await sleep(7000);
+
+  console.log('\nÀ regarder');
+  const link = (key, label) =>
+    rows[key] ? console.log(`  ${label.padEnd(34)} ${WEB}/torrents/${rows[key].infoHash}`) : null;
+  link('dune4k', 'remux 4K, tout allumé');
+  link('dune4kXseed', 'son cross-seed');
+  link('dune1080', 'remplacé par un PROPER');
+  link('dune1080proper', 'le PROPER');
+  link('bear', 'saison complète, upload x2');
+  link('flac', 'musique, pistes audio seules');
+  link('game', 'jeu, 28 fichiers');
+  link('ebook', 'aucun seeder -> demande de reseed');
+  link('pending', 'en attente de modération');
+  link('adult', 'voile adulte');
+  link('frierenE09a', 'épisode 09, 4 versions');
+  link('frierenS01a', 'saison 1, 2 versions');
+  link('frierenIntegral', 'intégrale, sans saison');
+  if (rows.dune4k) {
+    console.log(`  ${'groupe (quatre éditions)'.padEnd(34)} ${WEB}/torrents/group/tmdb:693134`);
+  }
+  if (rows.frierenE09a) {
+    console.log(`  ${'groupe (3 portées)'.padEnd(34)} ${WEB}/torrents/group/tmdb:tv/209867`);
+  }
+  console.log(`\n  ${steps} étapes, ${problems} en échec.`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
diff --git a/tests/e2e/docker-compose.yml b/tests/e2e/docker-compose.yml
index 8169d59d..742940a4 100644
--- a/tests/e2e/docker-compose.yml
+++ b/tests/e2e/docker-compose.yml
@@ -1,9 +1,9 @@
 # Throwaway end-to-end stack for the themes work.
 #
-# Deliberately lean: postgres, redis, api, web. No pgbouncer (the API talks to
-# Postgres directly, which is also how MIGRATIONS_DATABASE_URL works in prod),
-# no Caddy (the web container emits its own security headers, so the CSP under
-# test is the real one), no tracker (nothing here announces).
+# Deliberately lean: postgres, redis, api, web, relay, tracker. No pgbouncer (the
+# API talks to Postgres directly, which is also how MIGRATIONS_DATABASE_URL works
+# in prod), no Caddy (the web container emits its own security headers, so the CSP
+# under test is the real one).
 #
 # The API applies its committed migrations at boot, so this database is built by
 # the real chain from empty — which is exactly what an operator gets.
@@ -61,6 +61,26 @@ services:
       MESSAGING_TOKEN_SECRET: e2e-messaging-secret-0123456789abcdef
     ports:
       - "54000:4000"
+    # Métadonnées TMDb, quand l'exploitant en a une clé.
+    #
+    # Facultatif : la pile marche sans, et la carte d'identité rend alors son
+    # état « sans affiche » — le seul que la suite voyait, donc le seul qui
+    # avait jamais été regardé, alors qu'un titre, une affiche et un synopsis
+    # changent la mise en page de cette carte.
+    #
+    # Un FICHIER et non `${TMDB_API_KEY}` dans `environment`, parce qu'une
+    # substitution de shell se perd : `docker compose up -d web` lancé depuis un
+    # terminal où la variable n'est pas exportée réévalue la configuration de
+    # TOUS les services, voit `api` changer, et la recrée sans la clé. Silence
+    # complet, et l'affiche disparaît. `run.sh` écrit ce fichier depuis le
+    # `.env` de la racine ; `required: false` pour que la pile démarre sans.
+    #
+    # Un fichier dédié plutôt que le `.env` de la racine : `env_file` verse
+    # TOUT ce qu'il contient dans le conteneur, et la racine porte les secrets
+    # de production d'un exploitant.
+    env_file:
+      - path: ./tmdb.env
+        required: false
     volumes:
       - uploads:/app/data/uploads
     tmpfs:
@@ -133,5 +153,44 @@ services:
       - spa
       - api
 
+  # Le tracker, enfin.
+  #
+  # Le commentaire d'en-tête disait « no tracker (nothing here announces) », et
+  # c'était vrai : aucun scénario n'annonce. La conséquence n'était visible
+  # nulle part dans la suite mais elle l'est à l'œil nu sur une pile gardée —
+  # toute page qui montre un essaim montrait zéro pair, zéro seeder, zéro
+  # leecher, et la carte de décision de la page de détail rendait en
+  # permanence son état vide. On ne peut pas juger un affichage de swarm sans
+  # swarm.
+  #
+  # `demoTorrents.mjs` annonce ici avec la passkey réelle de chaque compte, donc
+  # ce que la page affiche vient du vrai chemin : announce → Redis → peers.
+  tracker:
+    image: trackarr-e2e-tracker:local
+    environment:
+      DATABASE_URL: postgres://tracker:tracker@postgres:5432/trackarr?sslmode=disable
+      DB_SSL: "false"
+      REDIS_URL: redis://redis:6379
+      REDIS_PASSWORD: e2e-redis-password
+      IP_HASH_SECRET: e2e-ip-hash-secret-0123456789abcdef
+      TRACKER_HTTP_PORT: 8080
+      # Versement des crédits d'octets en 5 s au lieu de 60 : sur une pile qu'on
+      # essaie à la main, attendre une minute pour voir un ratio bouger revient
+      # à croire que le compteur est cassé.
+      TRACKER_STATS_FLUSH_INTERVAL: 5s
+      TRUST_PROXY: "false"
+    ports:
+      - "54200:8080"
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+      # Le tracker ne migre pas ; c'est l'API qui applique la chaîne au boot.
+      # Sans cette attente il ouvre un pool sur une base encore vide et son
+      # premier announce échoue sur une table absente.
+      api:
+        condition: service_healthy
+
 volumes:
   uploads:
diff --git a/tests/e2e/import-dump.sh b/tests/e2e/import-dump.sh
new file mode 100755
index 00000000..30170251
--- /dev/null
+++ b/tests/e2e/import-dump.sh
@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+#
+# Verse les torrents d'un `pg_dump` d'exploitation dans la pile e2e gardée.
+#
+#   bash tests/e2e/import-dump.sh /chemin/vers/dump.sql
+#
+# Pourquoi ce script existe : un catalogue fabriqué à la main ne ressemble pas
+# à un vrai. `demoTorrents.mjs` dépose dix releases dont chaque champ a été
+# choisi pour éclairer un bout d'interface — donc chaque champ est propre, de la
+# bonne longueur, et rempli. Un vrai catalogue porte des descriptions de 3 Kio
+# avec des images mortes dedans, des NFO de 50 Kio, des identifiants TMDb saisis
+# par URL (`tv/34114` et non `34114`), des titres à rallonge et des champs
+# vides. Ce sont ces cas-là qui cassent une mise en page, et on ne les invente
+# pas.
+#
+# Ce qui est importé : `torrents` et ce qui y pend — catégories, étiquettes,
+# liaisons, commentaires, instantané d'essaim, favoris, fils de modération,
+# obligations de seed.
+#
+# Ce qui n'est PAS importé : la table `users`. Elle porte `auth_verifier`,
+# `passkey`, `totp_secret` et `panic_password_hash` — des secrets de l'instance
+# d'origine, qui n'ont rien à faire dans une pile jetable. Les identifiants
+# d'auteur et de propriétaire sont donc REMAPPÉS sur les comptes du harnais,
+# dont les mots de passe sont faux et publics.
+#
+# Le dump peut venir d'une version ANTÉRIEURE du schéma : les colonnes sont
+# lues dans son propre `COPY`, comparées à celles de la base qui tourne, et
+# l'import s'arrête net si une colonne du dump a disparu depuis. Les colonnes
+# AJOUTÉES depuis n'ont pas d'importance — elles ont toutes un défaut ou sont
+# nullables, sinon la migration qui les a créées n'aurait pas pu tourner.
+set -euo pipefail
+
+DUMP="${1:-}"
+if [ -z "$DUMP" ] || [ ! -f "$DUMP" ]; then
+  echo "usage: bash tests/e2e/import-dump.sh <dump.sql>" >&2
+  exit 2
+fi
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+COMPOSE="docker compose -f $HERE/docker-compose.yml"
+WORK="$(mktemp -d)"
+trap 'rm -rf "$WORK"' EXIT
+
+say() { printf '\n\033[1m▸ %s\033[0m\n' "$*"; }
+
+CID="$($COMPOSE ps -q postgres)"
+[ -n "$CID" ] || { echo "la pile e2e ne tourne pas — bash tests/e2e/run.sh --keep" >&2; exit 1; }
+
+say "extraction des blocs COPY"
+# Un bloc VIDE (`FROM stdin;` suivi immédiatement de `\.`) piège une capture
+# non gourmande : elle s'étend jusqu'au `\.` suivant et ramasse la table
+# d'après. D'où le découpage ligne à ligne plutôt qu'une expression régulière
+# sur tout le fichier.
+python3 - "$DUMP" "$WORK" <<'PY'
+import sys, pathlib
+dump, work = sys.argv[1], pathlib.Path(sys.argv[2])
+WANT = ['categories', 'tags', 'torrents', 'torrent_tags', 'torrent_comments',
+        'torrent_stats', 'torrent_favorites', 'torrent_moderation_messages',
+        'hnr_tracking']
+cols, counts = {}, {}
+current = None
+out = None
+for line in pathlib.Path(dump).open(encoding='utf8', errors='replace'):
+    if current is None:
+        if line.startswith('COPY public.'):
+            name = line[len('COPY public.'):].split(' ', 1)[0]
+            if name in WANT:
+                current = name
+                cols[name] = [c.strip() for c in line[line.index('(') + 1:line.index(')')].split(',')]
+                out = (work / f'{name}.tsv').open('w', encoding='utf8')
+                counts[name] = 0
+        continue
+    if line.rstrip('\n') == '\\.':
+        out.close(); current = None; out = None
+        continue
+    out.write(line); counts[current] += 1
+if out: out.close()
+# Le `\n` final n'est pas cosmétique : `while read` laisse tomber une dernière
+# ligne sans fin de ligne, et `pg_dump` émet les tables dans l'ordre
+# alphabétique — donc la ligne perdue était `torrents`, la seule qui compte
+# vraiment. Le contrôle affichait huit tables sur neuf et avait l'air complet.
+(work / 'columns.txt').write_text(
+    ''.join(f'{k}\t{",".join(v)}\n' for k, v in cols.items())
+)
+missing = [t for t in WANT if t not in cols]
+for t in WANT:
+    print(f'  {t:32} {counts.get(t, 0):>6} lignes' + ('  (absente du dump)' if t in missing else ''))
+PY
+
+say "contrôle des colonnes contre la base qui tourne"
+while IFS=$'\t' read -r table dumpcols; do
+  [ -n "$table" ] || continue
+  # `< /dev/null` : sans lui, `docker compose exec -T` lit STDIN — c'est-à-dire
+  # le reste de `columns.txt` — et la boucle s'arrête après la première table.
+  # Elle affichait « categories : ok » et rien d'autre, ce qui ressemble à un
+  # contrôle qui passe.
+  live=$($COMPOSE exec -T postgres psql -U tracker -d trackarr -tA -c \
+    "select string_agg(column_name, ',') from information_schema.columns where table_name='$table';" \
+    < /dev/null | tr -d '\r')
+  missing=""
+  IFS=',' read -ra want <<< "$dumpcols"
+  for c in "${want[@]}"; do
+    case ",$live," in *",$c,"*) ;; *) missing="$missing $c" ;; esac
+  done
+  if [ -n "$missing" ]; then
+    echo "  $table : colonnes du dump disparues depuis —$missing" >&2
+    echo "  L'import s'arrête : ces données n'ont plus de place où aller." >&2
+    exit 1
+  fi
+  echo "  $table : ok"
+done < "$WORK/columns.txt"
+
+say "copie dans le conteneur"
+# Une table absente du dump doit donner un fichier VIDE, pas un fichier
+# manquant : `COPY` d'un fichier absent echoue, `COPY` d'un fichier vide charge
+# zero ligne, et c'est exactement ce qu'on veut dire.
+for t in categories tags torrents torrent_tags torrent_comments torrent_stats \
+         torrent_favorites torrent_moderation_messages hnr_tracking; do
+  [ -f "$WORK/$t.tsv" ] || : > "$WORK/$t.tsv"
+done
+docker exec "$CID" sh -c 'rm -rf /tmp/imp && mkdir -p /tmp/imp'
+for f in "$WORK"/*.tsv; do docker cp "$f" "$CID:/tmp/imp/$(basename "$f")"; done
+# Les montages de Docker Desktop servent parfois un fichier tronqué sans le
+# dire. `docker cp` n'est pas un montage, mais le contrôle coûte une seconde et
+# un import à moitié copié est indétectable ensuite.
+for f in "$WORK"/*.tsv; do
+  b="$(basename "$f")"
+  a=$(md5 -q "$f" 2>/dev/null || md5sum "$f" | cut -d' ' -f1)
+  c=$(docker exec "$CID" md5sum "/tmp/imp/$b" | cut -d' ' -f1)
+  [ "$a" = "$c" ] || { echo "  $b : md5 différent après copie ($a vs $c)" >&2; exit 1; }
+done
+echo "  md5 identiques"
+
+docker cp "$HERE/import-dump.sql" "$CID:/tmp/imp/import.sql"
+
+say "import"
+docker exec "$CID" psql -U tracker -d trackarr -v ON_ERROR_STOP=1 -f /tmp/imp/import.sql
+
+say "terminé — donnez-leur un essaim avec : node tests/e2e/demoSwarm.mjs"
diff --git a/tests/e2e/import-dump.sql b/tests/e2e/import-dump.sql
new file mode 100644
index 00000000..7135ef4e
--- /dev/null
+++ b/tests/e2e/import-dump.sql
@@ -0,0 +1,170 @@
+BEGIN;
+
+-- ─────────────────────────────────────────────────────────────────────────────
+-- Tables de transit, aux colonnes de l'ANCIEN schéma.
+--
+-- Le dump date d'une version antérieure. Pour `torrents`, les 24 colonnes de
+-- l'époque sont un sous-ensemble strict des 33 d'aujourd'hui, et les neuf
+-- ajoutées sont toutes nullables ou pourvues d'un défaut — donc un INSERT à
+-- liste de colonnes explicite passe tel quel. Pour les huit tables liées, les
+-- colonnes sont identiques au nom près de l'ordre. Vérifié colonne par colonne
+-- contre `information_schema` de la base qui tourne, pas supposé.
+-- ─────────────────────────────────────────────────────────────────────────────
+
+CREATE TEMP TABLE s_categories (id text, name text, slug text, parent_id text,
+  created_at timestamp, newznab_id integer, is_adult boolean, type text, icon text);
+CREATE TEMP TABLE s_tags (id text, name text, slug text, color text, created_at timestamp);
+CREATE TEMP TABLE s_torrents (id text, info_hash text, name text, size bigint,
+  description text, torrent_data bytea, uploader_id text, category_id text,
+  is_active boolean, created_at timestamp, nfo text, imdb_id text, tmdb_id text,
+  tvdb_id text, moderation_status text, moderated_by_id text, moderated_at timestamp,
+  igdb_id text, openlibrary_id text, content_signature text, updated_at timestamp,
+  episode smallint, federate_swarm boolean, season smallint);
+CREATE TEMP TABLE s_torrent_tags (torrent_id text, tag_id text, created_at timestamp);
+CREATE TEMP TABLE s_comments (id text, torrent_id text, author_id text, content text,
+  created_at timestamp, updated_at timestamp);
+CREATE TEMP TABLE s_stats (info_hash text, seeders integer, leechers integer,
+  completed integer, updated_at timestamp);
+CREATE TEMP TABLE s_favorites (user_id text, torrent_id text, created_at timestamp);
+CREATE TEMP TABLE s_modmsgs (id text, torrent_id text, author_id text, body text,
+  is_system boolean, status_change text, created_at timestamp);
+CREATE TEMP TABLE s_hnr (id text, user_id text, torrent_id text, downloaded_at timestamp,
+  seed_time integer, required_seed_time integer, is_hnr boolean, is_exempt boolean,
+  completed_at timestamp, uploaded bigint, downloaded bigint);
+
+COPY s_categories FROM '/tmp/imp/categories.tsv';
+COPY s_tags FROM '/tmp/imp/tags.tsv';
+COPY s_torrents FROM '/tmp/imp/torrents.tsv';
+COPY s_torrent_tags FROM '/tmp/imp/torrent_tags.tsv';
+COPY s_comments FROM '/tmp/imp/torrent_comments.tsv';
+COPY s_stats FROM '/tmp/imp/torrent_stats.tsv';
+COPY s_favorites FROM '/tmp/imp/torrent_favorites.tsv';
+COPY s_modmsgs FROM '/tmp/imp/torrent_moderation_messages.tsv';
+COPY s_hnr FROM '/tmp/imp/hnr_tracking.tsv';
+
+-- ─────────────────────────────────────────────────────────────────────────────
+-- À qui rattacher tout ça.
+--
+-- Le dump ne porte qu'UN compte, et sa ligne `users` contient `auth_verifier`,
+-- `passkey`, `totp_secret` et `panic_password_hash` — des secrets de
+-- l'instance d'origine. Elle n'est pas importée. Les identifiants d'auteur et
+-- de propriétaire sont remappés sur les comptes que le harnais a créés, dont
+-- les mots de passe sont publics et faux.
+-- ─────────────────────────────────────────────────────────────────────────────
+CREATE TEMP TABLE who AS
+SELECT id, username, row_number() OVER (ORDER BY created_at) - 1 AS n
+  FROM users;
+
+CREATE TEMP TABLE founder AS SELECT id FROM users WHERE username = 'founder' LIMIT 1;
+
+-- ── Catégories ──────────────────────────────────────────────────────────────
+-- `categories_slug_unique` en plus de la clé primaire : deux contraintes
+-- uniques, donc un ON CONFLICT ne suffit pas. Filtre explicite.
+INSERT INTO categories (id, name, slug, parent_id, created_at, newznab_id, is_adult, type, icon)
+SELECT s.id, s.name, s.slug, s.parent_id, s.created_at, s.newznab_id, s.is_adult, s.type, s.icon
+  FROM s_categories s
+ WHERE NOT EXISTS (SELECT 1 FROM categories c WHERE c.id = s.id OR c.slug = s.slug);
+
+-- ── Étiquettes ──────────────────────────────────────────────────────────────
+-- `tags` porte TROIS index uniques (id, name, slug). Cinq étiquettes du dump
+-- existent déjà sous le même nom (1080p, BluRay, FLAC, 2160p, HEVC) : elles ne
+-- sont pas dupliquées, leur ancien identifiant est REMAPPÉ sur celui en place,
+-- sinon les 68 liaisons `torrent_tags` viseraient des lignes absentes.
+CREATE TEMP TABLE tag_map AS
+SELECT s.id AS old_id, COALESCE(m.id, s.id) AS new_id, (m.id IS NULL) AS fresh
+  FROM s_tags s
+  LEFT JOIN LATERAL (
+    SELECT t.id FROM tags t
+     WHERE lower(t.slug) = lower(s.slug) OR lower(t.name) = lower(s.name)
+     LIMIT 1
+  ) m ON true;
+
+INSERT INTO tags (id, name, slug, color, created_at)
+SELECT s.id, s.name, s.slug, s.color, s.created_at
+  FROM s_tags s JOIN tag_map m ON m.old_id = s.id AND m.fresh;
+
+-- ── Torrents ────────────────────────────────────────────────────────────────
+INSERT INTO torrents (
+  id, info_hash, name, size, description, torrent_data, uploader_id, category_id,
+  is_active, created_at, nfo, imdb_id, tmdb_id, tvdb_id, moderation_status,
+  moderated_by_id, moderated_at, igdb_id, openlibrary_id, content_signature,
+  updated_at, episode, federate_swarm, season)
+SELECT s.id, s.info_hash, s.name, s.size, s.description, s.torrent_data,
+       (SELECT id FROM founder), s.category_id,
+       s.is_active, s.created_at, s.nfo, s.imdb_id, s.tmdb_id, s.tvdb_id,
+       s.moderation_status,
+       CASE WHEN s.moderated_by_id IS NULL THEN NULL ELSE (SELECT id FROM founder) END,
+       s.moderated_at, s.igdb_id, s.openlibrary_id, s.content_signature,
+       s.updated_at, s.episode, s.federate_swarm, s.season
+  FROM s_torrents s
+ WHERE NOT EXISTS (SELECT 1 FROM torrents t WHERE t.id = s.id OR t.info_hash = s.info_hash);
+
+-- ── Liaisons, commentaires, essaim ──────────────────────────────────────────
+INSERT INTO torrent_tags (torrent_id, tag_id, created_at)
+SELECT s.torrent_id, m.new_id, s.created_at
+  FROM s_torrent_tags s
+  JOIN tag_map m ON m.old_id = s.tag_id
+ WHERE EXISTS (SELECT 1 FROM torrents t WHERE t.id = s.torrent_id)
+   AND EXISTS (SELECT 1 FROM tags g WHERE g.id = m.new_id)
+ON CONFLICT (torrent_id, tag_id) DO NOTHING;
+
+-- Les auteurs sont RÉPARTIS sur les comptes du harnais. Le dump n'en a qu'un,
+-- et un fil où tout le monde est la même personne ne dit rien de la mise en
+-- page d'un fil — c'est de la donnée de démonstration, pas une attribution.
+WITH numbered AS (
+  SELECT s.*, (row_number() OVER (ORDER BY s.created_at) - 1) AS rn
+    FROM s_comments s
+   WHERE EXISTS (SELECT 1 FROM torrents t WHERE t.id = s.torrent_id)
+)
+INSERT INTO torrent_comments (id, torrent_id, author_id, content, created_at, updated_at)
+SELECT n.id, n.torrent_id, w.id, n.content, n.created_at, n.updated_at
+  FROM numbered n
+  JOIN who w ON w.n = n.rn % (SELECT count(*) FROM who)
+ON CONFLICT (id) DO NOTHING;
+
+INSERT INTO torrent_stats (info_hash, seeders, leechers, completed, updated_at)
+SELECT s.info_hash, s.seeders, s.leechers, s.completed, s.updated_at
+  FROM s_stats s
+ WHERE EXISTS (SELECT 1 FROM torrents t WHERE t.info_hash = s.info_hash)
+ON CONFLICT (info_hash) DO UPDATE
+   SET seeders = excluded.seeders, leechers = excluded.leechers,
+       completed = excluded.completed, updated_at = excluded.updated_at;
+
+INSERT INTO torrent_favorites (user_id, torrent_id, created_at)
+SELECT (SELECT id FROM founder), s.torrent_id, s.created_at
+  FROM s_favorites s
+ WHERE EXISTS (SELECT 1 FROM torrents t WHERE t.id = s.torrent_id)
+ON CONFLICT (user_id, torrent_id) DO NOTHING;
+
+INSERT INTO torrent_moderation_messages (id, torrent_id, author_id, body, is_system, status_change, created_at)
+SELECT s.id, s.torrent_id,
+       CASE WHEN s.author_id IS NULL THEN NULL ELSE (SELECT id FROM founder) END,
+       s.body, s.is_system, s.status_change, s.created_at
+  FROM s_modmsgs s
+ WHERE EXISTS (SELECT 1 FROM torrents t WHERE t.id = s.torrent_id)
+ON CONFLICT (id) DO NOTHING;
+
+-- L'obligation de seed va sur `plainuser` : c'est le compte depuis lequel on
+-- regarde une page en tant que simple membre, et la carte d'obligation ne se
+-- rend que pour le membre concerné.
+INSERT INTO hnr_tracking (id, user_id, torrent_id, downloaded_at, seed_time,
+       required_seed_time, is_hnr, is_exempt, completed_at, uploaded, downloaded)
+SELECT s.id, (SELECT id FROM users WHERE username = 'plainuser' LIMIT 1), s.torrent_id,
+       s.downloaded_at, s.seed_time, s.required_seed_time, s.is_hnr, s.is_exempt,
+       s.completed_at, s.uploaded, s.downloaded
+  FROM s_hnr s
+ WHERE EXISTS (SELECT 1 FROM torrents t WHERE t.id = s.torrent_id)
+   AND EXISTS (SELECT 1 FROM users u WHERE u.username = 'plainuser')
+ON CONFLICT (user_id, torrent_id) DO NOTHING;
+
+COMMIT;
+
+SELECT 'categories' AS t, count(*) FROM categories
+UNION ALL SELECT 'tags', count(*) FROM tags
+UNION ALL SELECT 'torrents', count(*) FROM torrents
+UNION ALL SELECT 'torrent_tags', count(*) FROM torrent_tags
+UNION ALL SELECT 'torrent_comments', count(*) FROM torrent_comments
+UNION ALL SELECT 'torrent_stats', count(*) FROM torrent_stats
+UNION ALL SELECT 'torrent_favorites', count(*) FROM torrent_favorites
+UNION ALL SELECT 'mod_messages', count(*) FROM torrent_moderation_messages
+UNION ALL SELECT 'hnr_tracking', count(*) FROM hnr_tracking;
diff --git a/tests/e2e/lib.mjs b/tests/e2e/lib.mjs
index e2890e69..ef1f8f55 100644
--- a/tests/e2e/lib.mjs
+++ b/tests/e2e/lib.mjs
@@ -4,6 +4,7 @@
  * stack it owns.
  */
 import { connect } from 'node:net';
+import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 
 export const API = process.env.E2E_API ?? 'http://localhost:54000';
@@ -157,3 +158,95 @@ export function caller(S) {
     return { status: res.status, body: json, headers: res.headers };
   };
 }
+
+// ── Le tracker ───────────────────────────────────────────────────────
+//
+// Aucun scénario n'annonce, mais deux scripts de remplissage le font, et une
+// deuxième copie de ces trente lignes aurait dérivé de la première. Le tracker
+// est un service de la pile depuis que `docker-compose.yml` le monte.
+
+export const TRACKER = process.env.E2E_TRACKER ?? 'http://localhost:54200';
+
+/**
+ * Percent-encodage des octets bruts.
+ *
+ * `info_hash` et `peer_id` sont vingt octets binaires sur le fil, pas du
+ * texte : `encodeURIComponent` les corromprait en les traitant comme de
+ * l'UTF-8.
+ */
+export function pctEncodeBytes(buf) {
+  let s = '';
+  for (const b of buf) {
+    const unreserved =
+      (b >= 0x30 && b <= 0x39) ||
+      (b >= 0x41 && b <= 0x5a) ||
+      (b >= 0x61 && b <= 0x7a) ||
+      b === 0x2d ||
+      b === 0x2e ||
+      b === 0x5f ||
+      b === 0x7e;
+    s += unreserved ? String.fromCharCode(b) : `%${b.toString(16).padStart(2, '0')}`;
+  }
+  return s;
+}
+
+/**
+ * Un peer_id crédible, et STABLE pour une même graine.
+ *
+ * Le préfixe compte : `anticheat.Inspect` lève un drapeau quand un pair
+ * téléverse sous un préfixe BEP 20 inconnu ET un User-Agent qui ne ressemble
+ * à rien. On annonce donc comme qBittorrent, ce qui est aussi ce que fait un
+ * vrai pair.
+ *
+ * La stabilité est ce qui rend les scripts rejouables : la même graine
+ * réannonce le MÊME pair, donc l'essaim ne double pas à chaque relance.
+ */
+export function peerIdFor(seed) {
+  return Buffer.concat([
+    Buffer.from('-qB4650-', 'ascii'),
+    createHash('sha1').update(seed).digest().subarray(0, 12),
+  ]);
+}
+
+/**
+ * Une annonce, telle qu'un client l'émet.
+ *
+ * Renvoie `{ status, failure, text }`. `failure` est renseigné quand le
+ * tracker répond un échec — ce qu'il fait en bencode AVEC un 200
+ * (`d14:failure reason…e`), donc un appelant qui ne regarde que le code HTTP
+ * compte ses refus comme des réussites.
+ */
+export async function announce(
+  passkey,
+  infoHashHex,
+  seed,
+  { left, uploaded = 0, downloaded = 0, event, port = 6881 },
+) {
+  const q = [
+    `passkey=${passkey}`,
+    `info_hash=${pctEncodeBytes(Buffer.from(infoHashHex, 'hex'))}`,
+    `peer_id=${pctEncodeBytes(peerIdFor(seed))}`,
+    `port=${port}`,
+    `uploaded=${uploaded}`,
+    `downloaded=${downloaded}`,
+    `left=${left}`,
+    'compact=1',
+    'numwant=50',
+    ...(event ? [`event=${event}`] : []),
+  ].join('&');
+  const res = await fetch(`${TRACKER}/announce?${q}`, {
+    headers: { 'user-agent': 'qBittorrent/4.6.5' },
+  });
+  const text = await res.text();
+  const at = text.indexOf('14:failure reason');
+  const failure = at < 0 ? null : text.slice(at + 17).replace(/^\d+:/, '').slice(0, 70);
+  return { status: res.status, failure, text: text.slice(0, 120) };
+}
+
+/** La passkey d'annonce d'un membre, par le même appel que la page /me. */
+export async function passkeyOf(cookie) {
+  const res = await fetch(`${API}/api/auth/passkey`, { headers: { cookie } });
+  if (!res.ok) return null;
+  const body = await res.json().catch(() => null);
+  return body?.passkey ?? null;
+}
diff --git a/tests/e2e/run.sh b/tests/e2e/run.sh
index 94db16d4..fc02349e 100755
--- a/tests/e2e/run.sh
+++ b/tests/e2e/run.sh
@@ -48,6 +48,22 @@ if [ "$BUILD" = "1" ]; then
   # separate process, so a suite that never boots it proves nothing about
   # the split.
   docker build -q -f "$ROOT/apps/relay/Dockerfile" -t trackarr-e2e-relay:local "$ROOT"
+  # Le tracker aussi. Aucun scénario n'annonce, donc il ne sert à aucune
+  # assertion — mais sans lui une pile gardée montre un essaim vide partout, et
+  # c'est précisément ce qu'on vient regarder à l'œil nu. Voir docker-compose.yml.
+  docker build -q -f "$ROOT/apps/tracker/Dockerfile" -t trackarr-e2e-tracker:local "$ROOT"
+fi
+
+# La clé TMDb de l'exploitant, si le `.env` à la racine en porte une.
+#
+# Recopiée dans un fichier que le compose lit, et non exportée : une
+# substitution `${TMDB_API_KEY}` se perd au premier `docker compose up` lancé
+# depuis un terminal qui ne l'a pas — ce qui recrée `api` sans la clé, sans un
+# mot. Le fichier, lui, est relu à chaque fois.
+#
+# Le fichier est ignoré par git (voir .gitignore) : il porte un secret.
+if [ -f "$ROOT/.env" ]; then
+  grep -m1 '^TMDB_API_KEY=' "$ROOT/.env" > "$HERE/tmdb.env" || true
 fi
 
 say "booting"
@@ -133,7 +149,7 @@ for scenario in "$HERE"/*.mjs; do
   name="$(basename "$scenario" .mjs)"
   # `demo` et `forumTickets` remplissent une pile gardée pour l'essayer à la
   # main ; ce ne sont pas des scénarios et ils n'assertent rien.
-  case "$name" in seed|crypto|lib|demo|forumTickets) continue ;; esac
+  case "$name" in seed|crypto|lib|demo|demoTorrents|demoSwarm|forumTickets) continue ;; esac
   case " ${SCENARIOS[*]} " in *" $name "*) continue ;; esac
   echo "WARNING: $name.mjs is not in SCENARIOS and was not run" >&2
 done