diff --git a/apps/web/package.json b/apps/web/package.json
index 1ba2f80..c3137f8 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@typetype/web",
   "private": true,
-  "version": "1.3.1",
+  "version": "1.4.0",
   "type": "module",
   "scripts": {
     "dev": "vite",
diff --git a/apps/web/src/components/admin-session-card.tsx b/apps/web/src/components/admin-session-card.tsx
index ddce41c..55c151c 100644
--- a/apps/web/src/components/admin-session-card.tsx
+++ b/apps/web/src/components/admin-session-card.tsx
@@ -1,4 +1,4 @@
-import { toApiUrl } from "../lib/env";
+import { getAdminUserAvatarUrl } from "../lib/admin-user-avatar";
 import { getOpenMojiUrl, pickOpenMojiCode } from "../lib/openmoji";
 import type { AdminSession } from "../types/admin";
 import type { AuthUser } from "../types/auth";
@@ -26,9 +26,7 @@ function initials(value: string): string {
 }
 
 function avatarUrl(user: AuthUser | undefined, session: AdminSession): string | null {
-  if (user?.avatarType === "emoji" && user.avatarCode) return getOpenMojiUrl(user.avatarCode);
-  if (user?.avatarUrl) return toApiUrl(user.avatarUrl);
-  if (user) return getOpenMojiUrl(pickOpenMojiCode(`${user.id}:${user.email}`));
+  if (user) return getAdminUserAvatarUrl(user);
   if (session.userId) return getOpenMojiUrl(pickOpenMojiCode(session.userId));
   return null;
 }
diff --git a/apps/web/src/components/admin-user-avatar.tsx b/apps/web/src/components/admin-user-avatar.tsx
index cd9787d..1564820 100644
--- a/apps/web/src/components/admin-user-avatar.tsx
+++ b/apps/web/src/components/admin-user-avatar.tsx
@@ -1,5 +1,4 @@
-import { toApiUrl } from "../lib/env";
-import { getOpenMojiUrl, pickOpenMojiCode } from "../lib/openmoji";
+import { getAdminUserAvatarUrl } from "../lib/admin-user-avatar";
 import type { AuthUser } from "../types/auth";
 
 type AdminUserAvatarProps = {
@@ -8,13 +7,7 @@ type AdminUserAvatarProps = {
 };
 
 export function AdminUserAvatar({ user, className }: AdminUserAvatarProps) {
-  const seed = `${user.id}:${user.email}`;
-  const avatarUrl =
-    user.avatarType === "emoji" && typeof user.avatarCode === "string" && user.avatarCode.length > 0
-      ? getOpenMojiUrl(user.avatarCode)
-      : user.avatarUrl
-        ? toApiUrl(user.avatarUrl)
-        : getOpenMojiUrl(pickOpenMojiCode(seed));
+  const avatarUrl = getAdminUserAvatarUrl(user);
 
   return (
     <div
diff --git a/apps/web/src/components/channel-page-content.tsx b/apps/web/src/components/channel-page-content.tsx
index cf57e7b..5877bbd 100644
--- a/apps/web/src/components/channel-page-content.tsx
+++ b/apps/web/src/components/channel-page-content.tsx
@@ -41,7 +41,7 @@ export function ChannelPageContent({ sourceUrl, sort, searchQuery, tab, onNaviga
     fetchNextPage,
   } = useChannel(sourceUrl, sort, searchQuery, live);
   const { add, remove, isSubscribed } = useSubscriptions();
-  const { filter } = useBlockedFilter();
+  const { filter, isChannelIdentityBlocked } = useBlockedFilter();
   useDocumentTitle(meta?.name);
 
   const subscribed = isSubscribed(sourceUrl);
@@ -95,6 +95,14 @@ export function ChannelPageContent({ sourceUrl, sort, searchQuery, tab, onNaviga
       </div>
     );
   }
+  if (meta && isChannelIdentityBlocked({ url: sourceUrl, name: meta.name })) {
+    return (
+      <FamilyListEmptyState
+        title="This channel is blocked"
+        description="Unblock it from Settings to see this channel again."
+      />
+    );
+  }
 
   return (
     <div className="flex flex-col gap-6">
diff --git a/apps/web/src/components/continue-watching.tsx b/apps/web/src/components/continue-watching.tsx
index 0d715b9..1408a19 100644
--- a/apps/web/src/components/continue-watching.tsx
+++ b/apps/web/src/components/continue-watching.tsx
@@ -1,3 +1,5 @@
+import { useMemo } from "react";
+import { useBlockedFilter } from "../hooks/use-blocked-filter";
 import { useHistory } from "../hooks/use-history";
 import { isVideoInProgress } from "../lib/watch-progress";
 import { ContinueCard } from "./continue-card";
@@ -6,10 +8,15 @@ const MAX_ITEMS = 12;
 
 export function ContinueWatching() {
   const { items } = useHistory();
-  const displayed = items
-    .filter((h) => isVideoInProgress(h.progress, h.duration))
-    .sort((a, b) => b.watchedAt - a.watchedAt)
-    .slice(0, MAX_ITEMS);
+  const { filter } = useBlockedFilter();
+  const displayed = useMemo(
+    () =>
+      filter(items)
+        .filter((h) => isVideoInProgress(h.progress, h.duration))
+        .sort((a, b) => b.watchedAt - a.watchedAt)
+        .slice(0, MAX_ITEMS),
+    [filter, items],
+  );
   if (displayed.length === 0) return null;
 
   return (
diff --git a/apps/web/src/components/reset-token-modal.tsx b/apps/web/src/components/reset-token-modal.tsx
index ca67284..fe4913a 100644
--- a/apps/web/src/components/reset-token-modal.tsx
+++ b/apps/web/src/components/reset-token-modal.tsx
@@ -1,4 +1,5 @@
-import { useEffect } from "react";
+import { useEffect, useState } from "react";
+import { copyText } from "../lib/copy-text";
 
 type ResetTokenModalProps = {
   email: string;
@@ -8,14 +9,7 @@ type ResetTokenModalProps = {
 };
 
 export function ResetTokenModal({ email, token, onClose, onCopied }: ResetTokenModalProps) {
-  useEffect(() => {
-    navigator.clipboard
-      .writeText(token)
-      .then(() => {
-        onCopied();
-      })
-      .catch(() => {});
-  }, [token, onCopied]);
+  const [copyState, setCopyState] = useState<"idle" | "copied" | "manual">("idle");
 
   useEffect(() => {
     const handleEscape = (e: KeyboardEvent) => {
@@ -25,10 +19,13 @@ export function ResetTokenModal({ email, token, onClose, onCopied }: ResetTokenM
     return () => window.removeEventListener("keydown", handleEscape);
   }, [onClose]);
 
-  const handleCopy = () => {
-    navigator.clipboard.writeText(token).then(() => {
+  const handleCopy = async () => {
+    if (await copyText(token)) {
+      setCopyState("copied");
       onCopied();
-    });
+      return;
+    }
+    setCopyState("manual");
   };
 
   return (
@@ -52,18 +49,29 @@ export function ResetTokenModal({ email, token, onClose, onCopied }: ResetTokenM
           <p className="text-sm text-fg-muted mt-1">{email}</p>
         </div>
 
-        <div className="mb-4 p-3 rounded-lg bg-app border border-border">
-          <p className="text-xs font-mono text-fg break-all">{token}</p>
-        </div>
+        <textarea
+          readOnly
+          value={token}
+          aria-label="Password reset token"
+          onFocus={(event) => event.currentTarget.select()}
+          className="mb-4 block h-24 w-full resize-none rounded-lg border border-border bg-app p-3 font-mono text-xs text-fg"
+        />
 
-        <div className="mb-3 text-xs text-emerald-200 bg-emerald-950/30 border border-emerald-800/50 p-2 rounded">
-          Token copied to clipboard automatically
-        </div>
+        {copyState === "copied" && (
+          <div className="mb-3 rounded border border-emerald-800/50 bg-emerald-950/30 p-2 text-xs text-emerald-200">
+            Token copied to clipboard
+          </div>
+        )}
+        {copyState === "manual" && (
+          <div className="mb-3 rounded border border-border-strong bg-surface-strong p-2 text-xs text-fg-muted">
+            Clipboard access is unavailable. Select the token above and copy it manually.
+          </div>
+        )}
 
         <div className="flex gap-2">
           <button
             type="button"
-            onClick={handleCopy}
+            onClick={() => void handleCopy()}
             className="flex-1 h-9 rounded-md border border-border-strong bg-surface-strong px-3 text-sm font-medium text-fg hover:border-border-strong hover:bg-surface-soft transition-colors"
           >
             Copy token
diff --git a/apps/web/src/components/search-filter-bar.tsx b/apps/web/src/components/search-filter-bar.tsx
index 0cd6d18..27bbfe1 100644
--- a/apps/web/src/components/search-filter-bar.tsx
+++ b/apps/web/src/components/search-filter-bar.tsx
@@ -1,85 +1,209 @@
-import type { SearchFiltersResponse } from "../types/api";
-
-function prettifyLabel(raw: string): string {
-  const afterColon = raw.includes(":") ? raw.slice(raw.indexOf(":") + 1) : raw;
-  const base = afterColon.trim();
-  const stripped = base.startsWith("sort_") ? base.slice(5) : base;
-  return stripped
-    .split(/[_\s]+/)
-    .filter(Boolean)
-    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-    .join(" ");
-}
+import { SlidersHorizontal, X } from "lucide-react";
+import { useEffect, useRef, useState } from "react";
+import {
+  activeSearchFilterOptions,
+  searchFilterGroups,
+  searchFilterLabel,
+  toggleSearchFilter,
+} from "../lib/search-filter-selection";
+import type { SearchFilterGroup, SearchFilterOption, SearchFiltersResponse } from "../types/api";
 
 function chipClass(active: boolean): string {
   const base =
-    "shrink-0 whitespace-nowrap rounded-lg px-3 py-1.5 text-sm font-medium transition-colors";
+    "shrink-0 whitespace-nowrap rounded-md px-3 py-1.5 text-sm font-medium transition-colors";
   return active
     ? `${base} bg-fg text-app`
     : `${base} bg-surface-strong text-fg hover:bg-surface-soft`;
 }
 
+function isOptionSelected(
+  group: SearchFilterGroup,
+  option: SearchFilterOption,
+  selected: readonly string[],
+): boolean {
+  if (!option.isDefault) return selected.includes(option.value);
+  return !group.options.some(
+    (candidate) => !candidate.isDefault && selected.includes(candidate.value),
+  );
+}
+
 type Props = {
   filters: SearchFiltersResponse;
   contentFilter: string | undefined;
-  sortFilter: string | undefined;
+  selectedFilters: readonly string[];
   onContentChange: (value: string | undefined) => void;
-  onSortChange: (value: string | undefined) => void;
+  onFiltersChange: (values: string[]) => void;
 };
 
 export function SearchFilterBar({
   filters,
   contentFilter,
-  sortFilter,
+  selectedFilters,
   onContentChange,
-  onSortChange,
+  onFiltersChange,
 }: Props) {
-  const contentOptions = filters.contentFilters.filter((option) => option.label !== "all");
-  const { sortFilters } = filters;
+  const [open, setOpen] = useState(false);
+  const rootRef = useRef<HTMLDivElement>(null);
+  const groups = searchFilterGroups(filters);
+  const activeOptions = activeSearchFilterOptions(groups, selectedFilters);
+  const contentOptions = filters.contentFilters.filter(
+    (option) => !option.isDefault && searchFilterLabel(option.label).toLowerCase() !== "all",
+  );
 
-  if (contentOptions.length === 0 && sortFilters.length === 0) return null;
+  useEffect(() => {
+    if (!open) return;
+    const closeOutside = (event: MouseEvent) => {
+      if (!rootRef.current?.contains(event.target as Node)) setOpen(false);
+    };
+    const closeOnEscape = (event: KeyboardEvent) => {
+      if (event.key === "Escape") setOpen(false);
+    };
+    window.addEventListener("mousedown", closeOutside);
+    window.addEventListener("keydown", closeOnEscape);
+    return () => {
+      window.removeEventListener("mousedown", closeOutside);
+      window.removeEventListener("keydown", closeOnEscape);
+    };
+  }, [open]);
+
+  if (contentOptions.length === 0 && groups.length === 0) return null;
 
   return (
-    <div className="mb-5 flex flex-col gap-2">
-      <div className="flex gap-2 overflow-x-auto pb-1">
-        <button
-          type="button"
-          onClick={() => onContentChange(undefined)}
-          className={chipClass(!contentFilter)}
-        >
-          All
-        </button>
-        {contentOptions.map((option) => (
-          <button
-            key={option.value}
-            type="button"
-            onClick={() => onContentChange(option.value)}
-            className={chipClass(contentFilter === option.value)}
-          >
-            {prettifyLabel(option.label)}
-          </button>
-        ))}
-      </div>
-      {sortFilters.length > 0 && (
-        <div className="flex gap-2 overflow-x-auto pb-1">
+    <div ref={rootRef} className="relative mb-5 border-y border-border py-3">
+      <div className="flex min-w-0 items-center gap-3">
+        <div className="flex min-w-0 flex-1 gap-2 overflow-x-auto pb-0.5">
           <button
             type="button"
-            onClick={() => onSortChange(undefined)}
-            className={chipClass(!sortFilter)}
+            onClick={() => onContentChange(undefined)}
+            className={chipClass(!contentFilter)}
           >
-            Relevance
+            All
           </button>
-          {sortFilters.map((option) => (
+          {contentOptions.map((option) => (
             <button
               key={option.value}
               type="button"
-              onClick={() => onSortChange(option.value)}
-              className={chipClass(sortFilter === option.value)}
+              onClick={() => onContentChange(option.value)}
+              className={chipClass(contentFilter === option.value)}
             >
-              {prettifyLabel(option.label)}
+              {searchFilterLabel(option.label)}
             </button>
           ))}
         </div>
+        {groups.length > 0 && (
+          <button
+            type="button"
+            onClick={() => setOpen((value) => !value)}
+            aria-expanded={open}
+            aria-haspopup="dialog"
+            className={`flex h-9 shrink-0 items-center gap-2 rounded-md border px-3 text-sm font-medium transition-colors ${
+              open || activeOptions.length > 0
+                ? "border-fg bg-fg text-app"
+                : "border-border-strong bg-surface text-fg hover:bg-surface-strong"
+            }`}
+          >
+            <SlidersHorizontal size={16} aria-hidden="true" />
+            <span>Filters</span>
+            {activeOptions.length > 0 && (
+              <span className="min-w-5 rounded bg-app/15 px-1.5 text-center text-xs">
+                {activeOptions.length}
+              </span>
+            )}
+          </button>
+        )}
+      </div>
+
+      {activeOptions.length > 0 && (
+        <div className="mt-2.5 flex flex-wrap gap-2">
+          {activeOptions.map((option) => {
+            const group = groups.find((candidate) =>
+              candidate.options.some((candidateOption) => candidateOption.value === option.value),
+            );
+            if (!group) return null;
+            return (
+              <button
+                key={option.value}
+                type="button"
+                onClick={() =>
+                  onFiltersChange(toggleSearchFilter(groups, selectedFilters, group.key, option))
+                }
+                className="flex h-7 items-center gap-1.5 rounded-md bg-surface-strong px-2.5 text-xs text-fg transition-colors hover:bg-surface-soft"
+                title={`Remove ${searchFilterLabel(option.label)} filter`}
+              >
+                {searchFilterLabel(option.label)}
+                <X size={13} aria-hidden="true" />
+              </button>
+            );
+          })}
+        </div>
+      )}
+
+      {open && (
+        <div
+          role="dialog"
+          aria-label="Search filters"
+          className="absolute right-0 top-[calc(100%+0.5rem)] z-40 w-[min(28rem,calc(100vw-2rem))] overflow-hidden rounded-md border border-border-strong bg-surface shadow-2xl"
+        >
+          <div className="flex h-12 items-center justify-between border-b border-border px-4">
+            <h2 className="text-sm font-semibold text-fg">Filters</h2>
+            <div className="flex items-center gap-1">
+              {activeOptions.length > 0 && (
+                <button
+                  type="button"
+                  onClick={() => onFiltersChange([])}
+                  className="h-8 px-2 text-xs font-medium text-fg-muted transition-colors hover:text-fg"
+                >
+                  Reset
+                </button>
+              )}
+              <button
+                type="button"
+                onClick={() => setOpen(false)}
+                className="flex h-8 w-8 items-center justify-center rounded-md text-fg-muted transition-colors hover:bg-surface-strong hover:text-fg"
+                title="Close filters"
+              >
+                <X size={17} aria-hidden="true" />
+              </button>
+            </div>
+          </div>
+          <div className="max-h-[min(68vh,34rem)] overflow-y-auto px-4">
+            {groups.map((group) => (
+              <fieldset key={group.key} className="border-b border-border py-4 last:border-b-0">
+                <legend className="mb-2.5 text-xs font-semibold uppercase text-fg-muted">
+                  {searchFilterLabel(group.label)}
+                </legend>
+                <div className="grid grid-cols-1 gap-1 sm:grid-cols-2">
+                  {group.options.map((option) => {
+                    const checked = isOptionSelected(group, option, selectedFilters);
+                    return (
+                      <label
+                        key={option.value}
+                        className={`flex min-h-9 cursor-pointer items-center gap-2.5 rounded-md px-2.5 text-sm transition-colors ${
+                          checked
+                            ? "bg-surface-strong text-fg"
+                            : "text-fg-muted hover:bg-surface-strong/60 hover:text-fg"
+                        }`}
+                      >
+                        <input
+                          type={group.multiSelect ? "checkbox" : "radio"}
+                          name={group.multiSelect ? undefined : group.key}
+                          checked={checked}
+                          onChange={() =>
+                            onFiltersChange(
+                              toggleSearchFilter(groups, selectedFilters, group.key, option),
+                            )
+                          }
+                          className="h-4 w-4 shrink-0 accent-accent"
+                        />
+                        <span>{searchFilterLabel(option.label)}</span>
+                      </label>
+                    );
+                  })}
+                </div>
+              </fieldset>
+            ))}
+          </div>
+        </div>
       )}
     </div>
   );
diff --git a/apps/web/src/components/shorts-player-shell.tsx b/apps/web/src/components/shorts-player-shell.tsx
index 4964a1f..c8953c2 100644
--- a/apps/web/src/components/shorts-player-shell.tsx
+++ b/apps/web/src/components/shorts-player-shell.tsx
@@ -25,12 +25,11 @@ export function ShortsPlayerShell({ targetUrl }: Props) {
   const feed = useShortsFeed();
   const shorts = useShortsRouteFeed(feed.shorts, targetUrl);
   const { authReady, isAuthed } = useAuth();
-  const { data: instance, isPending: instancePending } = useInstance();
+  const { isPending: instancePending } = useInstance();
   const { settings, update, settingsReady } = useSettings();
   const playerRef = useRef<HTMLDivElement>(null);
   const [commentsOpen, setCommentsOpen] = useState(false);
-  const useAuthenticatedStream =
-    isAuthed && (settings.accessMode === "allow_list" || instance?.guestAllowed === false);
+  const useAuthenticatedStream = isAuthed;
   const streamEnabled = authReady && !instancePending && (!isAuthed || settingsReady);
 
   const handleAutoNext = () => {
diff --git a/apps/web/src/components/subtitle-track-utils.ts b/apps/web/src/components/subtitle-track-utils.ts
index 1f38c0e..a62c0c2 100644
--- a/apps/web/src/components/subtitle-track-utils.ts
+++ b/apps/web/src/components/subtitle-track-utils.ts
@@ -1,4 +1,4 @@
-import { toProxiedVttUrl } from "../lib/proxy";
+import { toSubtitleVttUrl } from "../lib/proxy";
 import type { SubtitleItem } from "../types/api";
 
 type SafeSubtitleTrack = {
@@ -46,7 +46,7 @@ export function buildSafeSubtitleTracks(
 
     let src = "";
     try {
-      src = toProxiedVttUrl(rawUrl);
+      src = toSubtitleVttUrl(rawUrl, normalizeText(item.languageTag), item.isAutoGenerated);
     } catch {
       continue;
     }
diff --git a/apps/web/src/components/video-card-feedback-panel.tsx b/apps/web/src/components/video-card-feedback-panel.tsx
index 901cf9e..8859a3f 100644
--- a/apps/web/src/components/video-card-feedback-panel.tsx
+++ b/apps/web/src/components/video-card-feedback-panel.tsx
@@ -1,6 +1,7 @@
 import { useState } from "react";
 import { useAuth } from "../hooks/use-auth";
 import { useBlocked } from "../hooks/use-blocked";
+import { useBlockedFilter } from "../hooks/use-blocked-filter";
 import { useWatchLaterPlaylist } from "../hooks/use-watch-later-playlist";
 import { goto } from "../lib/route-redirect";
 import { watchLaterResultLabel } from "../lib/watch-later-labels";
@@ -20,11 +21,15 @@ export function VideoCardFeedbackPanel({ stream, anchorEl, onClose, onSaved }: P
   const { isAuthed } = useAuth();
   const [playlistOpen, setPlaylistOpen] = useState(false);
   const watchLater = useWatchLaterPlaylist();
-  const { channels, videos, addChannel, removeChannel, addVideo, removeVideo } = useBlocked();
-  const channelBlocked =
-    !!stream.channelUrl &&
-    (channels.data ?? []).some((blocked) => blocked.url === stream.channelUrl);
-  const videoBlocked = (videos.data ?? []).some((blocked) => blocked.url === stream.id);
+  const { addChannel, removeChannel, addVideo, removeVideo } = useBlocked();
+  const { findBlockedChannel, findBlockedVideo } = useBlockedFilter();
+  const blockedChannel = findBlockedChannel({
+    url: stream.channelUrl,
+    name: stream.channelName,
+  });
+  const blockedVideo = findBlockedVideo(stream);
+  const channelBlocked = blockedChannel !== undefined;
+  const videoBlocked = blockedVideo !== undefined;
 
   function requireAuth(): boolean {
     if (isAuthed) return false;
@@ -35,7 +40,7 @@ export function VideoCardFeedbackPanel({ stream, anchorEl, onClose, onSaved }: P
   function toggleVideoBlock() {
     if (requireAuth()) return;
     if (videoBlocked) {
-      removeVideo.mutate(stream.id);
+      removeVideo.mutate(blockedVideo?.url ?? stream.id);
       return;
     }
     addVideo.mutate({ url: stream.id, global: false });
@@ -44,7 +49,7 @@ export function VideoCardFeedbackPanel({ stream, anchorEl, onClose, onSaved }: P
   function toggleChannelBlock() {
     if (!stream.channelUrl || requireAuth()) return;
     if (channelBlocked) {
-      removeChannel.mutate(stream.channelUrl);
+      removeChannel.mutate(blockedChannel?.url ?? stream.channelUrl);
       return;
     }
     addChannel.mutate({
diff --git a/apps/web/src/components/watch-layout.tsx b/apps/web/src/components/watch-layout.tsx
index f81a11e..cbe1f67 100644
--- a/apps/web/src/components/watch-layout.tsx
+++ b/apps/web/src/components/watch-layout.tsx
@@ -1,4 +1,5 @@
-import { useRef } from "react";
+import { useMemo, useRef } from "react";
+import { useBlockedFilter } from "../hooks/use-blocked-filter";
 import { useDeArrowBranding } from "../hooks/use-dearrow";
 import { useMobile } from "../hooks/use-mobile";
 import { usePlayerError } from "../hooks/use-player-error";
@@ -35,6 +36,7 @@ export function WatchLayout({
   const isMobile = useMobile();
   const save = useSaveProgress(stream.id);
   const { settings, update, settingsReady } = useSettings();
+  const { filter } = useBlockedFilter();
   const branding = useDeArrowBranding(stream.id, stream.title, stream.thumbnail, stream.duration);
   const displayStream = { ...stream, ...branding };
   const isLive = stream.streamType === "live_stream" || stream.streamType === "audio_live_stream";
@@ -42,7 +44,10 @@ export function WatchLayout({
   const { on: bulletCommentsOn } = useDanmakuStore();
   const { isNicoNico, bulletComments } = useWatchBulletComments(stream.id, settings.hideComments);
   const sponsor = useWatchSponsorBlock(stream, settings);
-  const relatedStreams = settings.hideRelatedVideos ? [] : (stream.related ?? []);
+  const relatedStreams = useMemo(
+    () => (settings.hideRelatedVideos ? [] : filter(stream.related ?? [])),
+    [filter, settings.hideRelatedVideos, stream.related],
+  );
   const playlist = useWatchPlaylist(list, shuffle, currentParam);
   const cinemaMode = useWatchLayoutStore((state) => state.cinemaMode);
   const seekRef = useRef<((seconds: number) => void) | null>(null);
@@ -55,6 +60,7 @@ export function WatchLayout({
   );
   const { autoplay, playerEvents } = useWatchPlaybackFlow({
     stream,
+    related: relatedStreams,
     settings,
     settingsReady,
     isLive,
diff --git a/apps/web/src/components/watch-more-actions.tsx b/apps/web/src/components/watch-more-actions.tsx
index 1b54fd1..c7355a1 100644
--- a/apps/web/src/components/watch-more-actions.tsx
+++ b/apps/web/src/components/watch-more-actions.tsx
@@ -1,5 +1,6 @@
 import { useRef, useState } from "react";
 import { useBlocked } from "../hooks/use-blocked";
+import { useBlockedFilter } from "../hooks/use-blocked-filter";
 import { useWatchLaterPlaylist } from "../hooks/use-watch-later-playlist";
 import { goto } from "../lib/route-redirect";
 import { watchLaterResultLabel } from "../lib/watch-later-labels";
@@ -19,11 +20,15 @@ export function WatchMoreActions({ stream, isAuthed, onSaved, className }: Props
   const [menuOpen, setMenuOpen] = useState(false);
   const menuAnchorRef = useRef<HTMLButtonElement>(null);
   const watchLater = useWatchLaterPlaylist();
-  const { channels, videos, addChannel, removeChannel, addVideo, removeVideo } = useBlocked();
-  const channelBlocked =
-    !!stream.channelUrl &&
-    (channels.data ?? []).some((blocked) => blocked.url === stream.channelUrl);
-  const videoBlocked = (videos.data ?? []).some((blocked) => blocked.url === stream.id);
+  const { addChannel, removeChannel, addVideo, removeVideo } = useBlocked();
+  const { findBlockedChannel, findBlockedVideo } = useBlockedFilter();
+  const blockedChannel = findBlockedChannel({
+    url: stream.channelUrl,
+    name: stream.channelName,
+  });
+  const blockedVideo = findBlockedVideo(stream);
+  const channelBlocked = blockedChannel !== undefined;
+  const videoBlocked = blockedVideo !== undefined;
 
   function ensureAuth(): boolean {
     if (isAuthed) return true;
@@ -34,7 +39,7 @@ export function WatchMoreActions({ stream, isAuthed, onSaved, className }: Props
   function toggleVideoBlock() {
     if (!ensureAuth()) return;
     if (videoBlocked) {
-      removeVideo.mutate(stream.id);
+      removeVideo.mutate(blockedVideo?.url ?? stream.id);
       onSaved("Video unblocked");
       return;
     }
@@ -45,7 +50,7 @@ export function WatchMoreActions({ stream, isAuthed, onSaved, className }: Props
   function toggleChannelBlock() {
     if (!stream.channelUrl || !ensureAuth()) return;
     if (channelBlocked) {
-      removeChannel.mutate(stream.channelUrl);
+      removeChannel.mutate(blockedChannel?.url ?? stream.channelUrl);
       onSaved("Channel unblocked");
       return;
     }
diff --git a/apps/web/src/hooks/use-blocked-filter.ts b/apps/web/src/hooks/use-blocked-filter.ts
index 9e4568c..f1e15f6 100644
--- a/apps/web/src/hooks/use-blocked-filter.ts
+++ b/apps/web/src/hooks/use-blocked-filter.ts
@@ -1,8 +1,11 @@
 import { useCallback, useMemo } from "react";
-import { normalizeBlockedKeyword, titleMatchesBlockedKeyword } from "../lib/blocked-keyword-filter";
+import {
+  type BlockableVideo,
+  type BlockedChannelIdentity,
+  createBlockedContentMatcher,
+} from "../lib/blocked-content";
 import type { ChannelResultItem } from "../types/api";
 import type { PublicPlaylistInfo } from "../types/playlist";
-import type { VideoStream } from "../types/stream";
 import { useAuth } from "./use-auth";
 import { useBlocked } from "./use-blocked";
 
@@ -10,63 +13,69 @@ export function useBlockedFilter() {
   const { isAuthed } = useAuth();
   const { channels, videos, keywords } = useBlocked();
 
-  const blockedChannelUrls = useMemo(
-    () => new Set((channels.data ?? []).map((item) => item.url)),
-    [channels.data],
-  );
-  const blockedVideoUrls = useMemo(
-    () => new Set((videos.data ?? []).map((item) => item.url)),
-    [videos.data],
-  );
-  const blockedChannelNames = useMemo(
-    () => new Set((channels.data ?? []).map((item) => item.name?.toLowerCase()).filter(Boolean)),
-    [channels.data],
-  );
-  const blockedKeywords = useMemo(
+  const matcher = useMemo(
     () =>
-      (keywords.data ?? [])
-        .map((item) => normalizeBlockedKeyword(item.keyword))
-        .filter((keyword) => keyword.length > 0),
-    [keywords.data],
+      createBlockedContentMatcher(
+        isAuthed ? (channels.data ?? []) : [],
+        isAuthed ? (videos.data ?? []) : [],
+        isAuthed ? (keywords.data ?? []).map((item) => item.keyword) : [],
+      ),
+    [channels.data, isAuthed, keywords.data, videos.data],
   );
 
   const isBlocked = useCallback(
-    (stream: VideoStream): boolean => {
-      if (blockedVideoUrls.has(stream.id)) return true;
-      if (stream.channelUrl && blockedChannelUrls.has(stream.channelUrl)) return true;
-      return titleMatchesBlockedKeyword(stream.title, blockedKeywords);
-    },
-    [blockedChannelUrls, blockedKeywords, blockedVideoUrls],
+    (stream: BlockableVideo): boolean => matcher.isVideoBlocked(stream),
+    [matcher],
   );
 
   const filter = useCallback(
-    (streams: VideoStream[]): VideoStream[] => {
-      if (!isAuthed) return streams;
-      return streams.filter((s) => !isBlocked(s));
-    },
-    [isAuthed, isBlocked],
+    <T extends BlockableVideo>(streams: T[]): T[] => matcher.filterVideos(streams),
+    [matcher],
+  );
+
+  const isChannelIdentityBlocked = useCallback(
+    (channel: BlockedChannelIdentity): boolean => matcher.isChannelBlocked(channel),
+    [matcher],
+  );
+
+  const findBlockedChannel = useCallback(
+    (channel: BlockedChannelIdentity) => matcher.findBlockedChannel(channel),
+    [matcher],
   );
 
   const isChannelBlocked = useCallback(
-    (channel: ChannelResultItem): boolean => blockedChannelUrls.has(channel.url),
-    [blockedChannelUrls],
+    (channel: ChannelResultItem): boolean => isChannelIdentityBlocked(channel),
+    [isChannelIdentityBlocked],
+  );
+
+  const isVideoExplicitlyBlocked = useCallback(
+    (video: Pick<BlockableVideo, "id" | "url">): boolean => matcher.isVideoExplicitlyBlocked(video),
+    [matcher],
+  );
+
+  const findBlockedVideo = useCallback(
+    (video: Pick<BlockableVideo, "id" | "url">) => matcher.findBlockedVideo(video),
+    [matcher],
   );
 
   const isPlaylistBlocked = useCallback(
     (playlist: PublicPlaylistInfo): boolean => {
-      const uploader = playlist.uploaderName.trim().toLowerCase();
-      return uploader.length > 0 && blockedChannelNames.has(uploader);
+      return isChannelIdentityBlocked({ name: playlist.uploaderName });
     },
-    [blockedChannelNames],
+    [isChannelIdentityBlocked],
   );
 
   return {
     filter,
+    findBlockedChannel,
+    findBlockedVideo,
     isBlocked,
     isChannelBlocked,
+    isChannelIdentityBlocked,
     isPlaylistBlocked,
-    blockedChannelUrls,
-    blockedKeywords,
-    blockedVideoUrls,
+    isVideoExplicitlyBlocked,
+    blockedChannelUrls: matcher.channelUrls,
+    blockedKeywords: matcher.normalizedKeywords,
+    blockedVideoUrls: matcher.videoUrls,
   };
 }
diff --git a/apps/web/src/hooks/use-blocked.ts b/apps/web/src/hooks/use-blocked.ts
index da72c68..15edbca 100644
--- a/apps/web/src/hooks/use-blocked.ts
+++ b/apps/web/src/hooks/use-blocked.ts
@@ -12,10 +12,6 @@ import {
 } from "../lib/api-collections";
 import { useAuth } from "./use-auth";
 
-const CHANNELS_KEY = ["blocked-channels"];
-const KEYWORDS_KEY = ["blocked-keywords"];
-const VIDEOS_KEY = ["blocked-videos"];
-
 type BlockChannelArgs = {
   url: string;
   name?: string;
@@ -30,22 +26,26 @@ type BlockVideoArgs = {
 
 export function useBlocked() {
   const qc = useQueryClient();
-  const { authReady, isAuthed } = useAuth();
+  const { authReady, isAuthed, me } = useAuth();
+  const owner = isAuthed ? (me?.id ?? "authenticated") : "signed-out";
+  const channelsKey = ["blocked-channels", owner] as const;
+  const keywordsKey = ["blocked-keywords", owner] as const;
+  const videosKey = ["blocked-videos", owner] as const;
 
   const channels = useQuery({
-    queryKey: CHANNELS_KEY,
+    queryKey: channelsKey,
     queryFn: fetchBlockedChannels,
     enabled: authReady && isAuthed,
     staleTime: 5 * 60 * 1000,
   });
   const videos = useQuery({
-    queryKey: VIDEOS_KEY,
+    queryKey: videosKey,
     queryFn: fetchBlockedVideos,
     enabled: authReady && isAuthed,
     staleTime: 5 * 60 * 1000,
   });
   const keywords = useQuery({
-    queryKey: KEYWORDS_KEY,
+    queryKey: keywordsKey,
     queryFn: fetchBlockedKeywords,
     enabled: authReady && isAuthed,
     staleTime: 5 * 60 * 1000,
@@ -54,34 +54,34 @@ export function useBlocked() {
   const addChannel = useMutation({
     mutationFn: ({ url, name, thumbnailUrl, global }: BlockChannelArgs) =>
       isAuthed ? blockChannel(url, name, thumbnailUrl, global) : Promise.resolve(),
-    onSuccess: () => qc.invalidateQueries({ queryKey: CHANNELS_KEY }),
+    onSuccess: () => qc.invalidateQueries({ queryKey: channelsKey }),
   });
 
   const removeChannel = useMutation({
     mutationFn: (url: string) => (isAuthed ? unblockChannel(url) : Promise.resolve()),
-    onSuccess: () => qc.invalidateQueries({ queryKey: CHANNELS_KEY }),
+    onSuccess: () => qc.invalidateQueries({ queryKey: channelsKey }),
   });
 
   const addVideo = useMutation({
     mutationFn: ({ url, global }: BlockVideoArgs) =>
       isAuthed ? blockVideo(url, global) : Promise.resolve(),
-    onSuccess: () => qc.invalidateQueries({ queryKey: VIDEOS_KEY }),
+    onSuccess: () => qc.invalidateQueries({ queryKey: videosKey }),
   });
 
   const removeVideo = useMutation({
     mutationFn: (url: string) => (isAuthed ? unblockVideo(url) : Promise.resolve()),
-    onSuccess: () => qc.invalidateQueries({ queryKey: VIDEOS_KEY }),
+    onSuccess: () => qc.invalidateQueries({ queryKey: videosKey }),
   });
 
   const addKeyword = useMutation({
     mutationFn: (keyword: string) =>
       isAuthed ? blockKeyword(keyword).then(() => undefined) : Promise.resolve(),
-    onSuccess: () => qc.invalidateQueries({ queryKey: KEYWORDS_KEY }),
+    onSuccess: () => qc.invalidateQueries({ queryKey: keywordsKey }),
   });
 
   const removeKeyword = useMutation({
     mutationFn: (keyword: string) => (isAuthed ? unblockKeyword(keyword) : Promise.resolve()),
-    onSuccess: () => qc.invalidateQueries({ queryKey: KEYWORDS_KEY }),
+    onSuccess: () => qc.invalidateQueries({ queryKey: keywordsKey }),
   });
 
   return {
diff --git a/apps/web/src/hooks/use-search-filters.ts b/apps/web/src/hooks/use-search-filters.ts
index 5d1acc4..a834a9e 100644
--- a/apps/web/src/hooks/use-search-filters.ts
+++ b/apps/web/src/hooks/use-search-filters.ts
@@ -1,10 +1,10 @@
 import { useQuery } from "@tanstack/react-query";
 import { fetchSearchFilters } from "../lib/api-discovery";
 
-export function useSearchFilters(service: number) {
+export function useSearchFilters(service: number, contentFilter?: string) {
   return useQuery({
-    queryKey: ["search-filters", service],
-    queryFn: () => fetchSearchFilters(service),
+    queryKey: ["search-filters", service, contentFilter ?? ""],
+    queryFn: () => fetchSearchFilters(service, contentFilter),
     staleTime: 60 * 60 * 1000,
   });
 }
diff --git a/apps/web/src/hooks/use-search.ts b/apps/web/src/hooks/use-search.ts
index a8c3d99..4899dff 100644
--- a/apps/web/src/hooks/use-search.ts
+++ b/apps/web/src/hooks/use-search.ts
@@ -14,11 +14,16 @@ type SearchPage = {
   isCorrectedSearch: boolean;
 };
 
-export function useSearch(q: string, service: number, contentFilter?: string, sortFilter?: string) {
+export function useSearch(
+  q: string,
+  service: number,
+  contentFilter?: string,
+  filters: readonly string[] = [],
+) {
   return useInfiniteQuery({
-    queryKey: ["search", q, service, contentFilter ?? "", sortFilter ?? ""],
+    queryKey: ["search", q, service, contentFilter ?? "", filters],
     queryFn: async ({ pageParam }: { pageParam: string | undefined }) => {
-      const response = await fetchSearch(q, service, pageParam, contentFilter, sortFilter);
+      const response = await fetchSearch(q, service, pageParam, contentFilter, filters);
       return {
         streams: response.items.map(mapVideoItem),
         channels: response.channels ?? [],
diff --git a/apps/web/src/hooks/use-stream.ts b/apps/web/src/hooks/use-stream.ts
index f30572e..991679d 100644
--- a/apps/web/src/hooks/use-stream.ts
+++ b/apps/web/src/hooks/use-stream.ts
@@ -11,10 +11,12 @@ import {
   sabrBootstrapQueryKey,
   streamQueryKey,
 } from "../lib/stream-request";
+import { useAuthStore } from "../stores/auth-store";
 
 export function streamQueryOptions(url: string, useAuthenticatedStream = false, enabled = true) {
+  const ownerId = useAuthenticatedStream ? useAuthStore.getState().me?.id : null;
   return queryOptions({
-    queryKey: streamQueryKey(url, useAuthenticatedStream),
+    queryKey: streamQueryKey(url, useAuthenticatedStream, ownerId),
     queryFn: ({ signal }) =>
       fetchStream(
         url,
@@ -62,8 +64,10 @@ export function useStream(url: string, useAuthenticatedStream = false, enabled =
 }
 
 export function useSabrBootstrap(url: string, useAuthenticatedStream = false, enabled = true) {
+  const authenticatedOwnerId = useAuthStore((state) => state.me?.id);
+  const ownerId = useAuthenticatedStream ? authenticatedOwnerId : null;
   return useQuery({
-    queryKey: sabrBootstrapQueryKey(url, useAuthenticatedStream),
+    queryKey: sabrBootstrapQueryKey(url, useAuthenticatedStream, ownerId),
     queryFn: ({ signal }) =>
       fetchSabrBootstrap(
         url,
diff --git a/apps/web/src/hooks/use-watch-autoplay-preload.ts b/apps/web/src/hooks/use-watch-autoplay-preload.ts
index f05e07d..58b33ff 100644
--- a/apps/web/src/hooks/use-watch-autoplay-preload.ts
+++ b/apps/web/src/hooks/use-watch-autoplay-preload.ts
@@ -21,13 +21,12 @@ export function useWatchAutoplayPreload({ durationMs, enabled, target }: Args) {
   const queryClient = useQueryClient();
   const token = useAuthStore((state) => state.token);
   const { authReady, isAuthed } = useAuth();
-  const { data: instance, isPending: instancePending } = useInstance();
-  const { settings, settingsReady } = useSettings();
+  const { isPending: instancePending } = useInstance();
+  const { settingsReady } = useSettings();
   const preloadedRef = useRef(new Set<string>());
   const activeRef = useRef<AbortController | null>(null);
   const activeTargetIdRef = useRef("");
-  const useAuthenticatedStream =
-    isAuthed && (settings.accessMode === "allow_list" || instance?.guestAllowed === false);
+  const useAuthenticatedStream = isAuthed;
   const ready = authReady && !instancePending && (!isAuthed || settingsReady);
   const targetId = target?.id ?? "";
 
diff --git a/apps/web/src/hooks/use-watch-playback-flow.ts b/apps/web/src/hooks/use-watch-playback-flow.ts
index c44256a..8c9ef37 100644
--- a/apps/web/src/hooks/use-watch-playback-flow.ts
+++ b/apps/web/src/hooks/use-watch-playback-flow.ts
@@ -7,6 +7,7 @@ import { useWatchPlayerEvents } from "./use-watch-player-events";
 
 type Args = {
   stream: VideoStream;
+  related: VideoStream[];
   settings: SettingsItem;
   settingsReady: boolean;
   isLive: boolean;
@@ -29,7 +30,7 @@ export function useWatchPlaybackFlow(args: Args) {
     nextVideo: args.nextVideo,
     list: args.list,
     shuffle: args.shuffle,
-    related: args.stream.related,
+    related: args.related,
   });
   const preloadAutoplay = useWatchAutoplayPreload({
     durationMs: args.stream.duration * 1000,
diff --git a/apps/web/src/hooks/use-watch-playlist.tsx b/apps/web/src/hooks/use-watch-playlist.tsx
index 96b43d6..a07b35d 100644
--- a/apps/web/src/hooks/use-watch-playlist.tsx
+++ b/apps/web/src/hooks/use-watch-playlist.tsx
@@ -7,6 +7,7 @@ import { markWatchAutoplayIntent } from "../lib/watch-autoplay-intent";
 import { toPublicWatchParam } from "../lib/watch-url";
 import { usePlaylistOrderStore } from "../stores/playlist-order-store";
 import type { WatchPlaylistItem } from "../types/playlist";
+import { useBlockedFilter } from "./use-blocked-filter";
 import { usePlaylist } from "./use-playlist";
 import { usePlaylists } from "./use-playlists";
 import { usePublicPlaylist } from "./use-public-playlist";
@@ -28,6 +29,7 @@ export function useWatchPlaylist(
   currentParam: string,
 ): WatchPlaylist {
   const navigate = useNavigate();
+  const { filter } = useBlockedFilter();
   const managedList = list && isManagedPlaylistId(list) ? list : "";
   const publicListUrl =
     list && !isManagedPlaylistId(list) ? `https://www.youtube.com/playlist?list=${list}` : "";
@@ -47,6 +49,7 @@ export function useWatchPlaylist(
         title: item.title,
         thumbnail: item.thumbnail,
         channelName: item.channelName,
+        channelUrl: item.channelUrl,
       }))
     : (publicPlaylist.data?.pages.flatMap((page) => page.streams) ?? []).map((item, index) => ({
         key: `${index}-${item.id}`,
@@ -54,8 +57,11 @@ export function useWatchPlaylist(
         title: item.title,
         thumbnail: item.thumbnail,
         channelName: item.channelName,
+        channelUrl: item.channelUrl,
       }));
-  const arranged = !isManaged && customOrder ? applyCustomOrder(base, customOrder) : base;
+  const visibleBase = filter(base);
+  const arranged =
+    !isManaged && customOrder ? applyCustomOrder(visibleBase, customOrder) : visibleBase;
   const videos = shuffle ? shuffleByKey(arranged, shuffle) : arranged;
   const inPlaylist = Boolean(list) && videos.length > 0;
   const currentIdx = inPlaylist
@@ -121,8 +127,14 @@ export function useWatchPlaylist(
           })
         }
         onReorder={(items) => {
-          if (isManaged && list) reorder.mutate({ id: list, order: items.map((v) => v.url) });
-          else if (list)
+          if (isManaged && list) {
+            const reordered = [...items];
+            const visibleKeys = new Set(visibleBase.map((item) => item.key));
+            const fullOrder = base.map((item) =>
+              visibleKeys.has(item.key) ? (reordered.shift() ?? item).url : item.url,
+            );
+            reorder.mutate({ id: list, order: fullOrder });
+          } else if (list)
             setOrder(
               list,
               items.map((v) => v.key),
diff --git a/apps/web/src/lib/admin-user-avatar.ts b/apps/web/src/lib/admin-user-avatar.ts
new file mode 100644
index 0000000..4487f53
--- /dev/null
+++ b/apps/web/src/lib/admin-user-avatar.ts
@@ -0,0 +1,11 @@
+import type { AuthUser } from "../types/auth";
+import { toApiUrl } from "./env";
+import { getOpenMojiUrl, pickOpenMojiCode } from "./openmoji";
+
+export function getAdminUserAvatarUrl(user: AuthUser): string {
+  if (user.avatarType === "emoji" && user.avatarCode) {
+    return getOpenMojiUrl(user.avatarCode);
+  }
+  if (user.avatarUrl) return toApiUrl(user.avatarUrl);
+  return getOpenMojiUrl(pickOpenMojiCode(user.id));
+}
diff --git a/apps/web/src/lib/api-discovery.ts b/apps/web/src/lib/api-discovery.ts
index aaa7f87..ce5a6e2 100644
--- a/apps/web/src/lib/api-discovery.ts
+++ b/apps/web/src/lib/api-discovery.ts
@@ -5,8 +5,13 @@ import { optionalBearer } from "./optional-bearer";
 
 export type ChannelSort = "latest" | "popular" | "oldest";
 
-export function fetchSearchFilters(service: number): Promise<SearchFiltersResponse> {
-  return request(`${BASE}/search/filters?service=${service}`);
+export function fetchSearchFilters(
+  service: number,
+  contentFilter?: string,
+): Promise<SearchFiltersResponse> {
+  const params = new URLSearchParams({ service: String(service) });
+  if (contentFilter) params.set("contentFilter", contentFilter);
+  return request(`${BASE}/search/filters?${params}`);
 }
 
 export function fetchSearch(
@@ -14,12 +19,12 @@ export function fetchSearch(
   service: number,
   nextpage?: string,
   contentFilter?: string,
-  sortFilter?: string,
+  filters: readonly string[] = [],
 ): Promise<SearchPageResponse> {
   const params = new URLSearchParams({ q, service: String(service) });
   if (nextpage) params.set("nextpage", nextpage);
   if (contentFilter) params.set("contentFilter", contentFilter);
-  if (sortFilter) params.set("sortFilter", sortFilter);
+  for (const filter of filters) params.append("filter", filter);
   return request(`${BASE}/search?${params}`, optionalBearer());
 }
 
diff --git a/apps/web/src/lib/auth-session.ts b/apps/web/src/lib/auth-session.ts
index bc807e7..261ebb4 100644
--- a/apps/web/src/lib/auth-session.ts
+++ b/apps/web/src/lib/auth-session.ts
@@ -17,6 +17,10 @@ type RegisterPayload = {
 
 let refreshInFlight: Promise<string> | null = null;
 
+export function isRefreshSessionRejected(error: unknown): boolean {
+  return error instanceof ApiError && error.status === 401;
+}
+
 async function hydrateSession(token: string): Promise<AuthMe> {
   const me = await fetchMe(token);
   useAuthStore.getState().setSession(token, me);
@@ -48,8 +52,12 @@ export async function bootstrapSession(): Promise<void> {
       try {
         await refreshSession();
         return;
-      } catch {
-        setSignedOut();
+      } catch (refreshError) {
+        if (isRefreshSessionRejected(refreshError) || !me) {
+          setSignedOut();
+          return;
+        }
+        setSession(token, me);
         return;
       }
     }
diff --git a/apps/web/src/lib/authed.ts b/apps/web/src/lib/authed.ts
index 24d8f18..b63146b 100644
--- a/apps/web/src/lib/authed.ts
+++ b/apps/web/src/lib/authed.ts
@@ -1,7 +1,7 @@
 import { useAuthStore } from "../stores/auth-store";
 import { ApiError } from "./api";
 import { recordApiError } from "./api-error-log";
-import { refreshSession } from "./auth-session";
+import { isRefreshSessionRejected, refreshSession } from "./auth-session";
 import { extractRequestId, recordClientEvent } from "./client-debug-log";
 import { sanitizeDebugText, sanitizeRequestPath } from "./debug-sanitize";
 import { normalizeApiPayload } from "./text-normalize";
@@ -20,32 +20,15 @@ function shouldLogStatus(status: number, options: AuthedOptions | undefined): bo
   return !(options?.silentStatuses ?? []).includes(status);
 }
 
-export async function authed(
+async function fetchAuthed(
   url: string,
-  init?: RequestInit,
-  options?: AuthedOptions,
+  init: RequestInit | undefined,
+  token: string,
+  method: string,
+  path: string,
 ): Promise<Response> {
-  const method = init?.method ?? "GET";
-  const path = sanitizeRequestPath(url);
-  let token = useAuthStore.getState().token;
-  if (!token) {
-    recordClientEvent("auth.missing_token_try_refresh", { method, path });
-    try {
-      token = await refreshSession();
-    } catch {
-      useAuthStore.getState().setSignedOut();
-      recordApiError({
-        endpoint: url,
-        status: 401,
-        code: "AUTH_REQUIRED",
-        message: "Authentication required",
-      });
-      throw new ApiError("Authentication required", 401);
-    }
-  }
-  let res: Response;
   try {
-    res = await fetch(url, withBearer(init, token));
+    return await fetch(url, withBearer(init, token));
   } catch (error) {
     const message = error instanceof Error ? error.message : "network_error";
     recordApiError({
@@ -61,38 +44,66 @@ export async function authed(
     });
     throw error;
   }
+}
+
+function rejectExpiredSession(message: "Authentication required" | "Session expired"): never {
+  useAuthStore.getState().setSignedOut();
+  recordApiError({
+    endpoint: "/auth/refresh",
+    status: 401,
+    code: message === "Session expired" ? "SESSION_EXPIRED" : "AUTH_REQUIRED",
+    message,
+  });
+  throw new ApiError(message, 401);
+}
+
+export async function authed(
+  url: string,
+  init?: RequestInit,
+  options?: AuthedOptions,
+): Promise<Response> {
+  const method = init?.method ?? "GET";
+  const path = sanitizeRequestPath(url);
+  let token = useAuthStore.getState().token;
+  if (!token) {
+    recordClientEvent("auth.missing_token_try_refresh", { method, path });
+    try {
+      token = await refreshSession();
+    } catch (error) {
+      if (isRefreshSessionRejected(error)) rejectExpiredSession("Authentication required");
+      throw error;
+    }
+  }
+  const res = await fetchAuthed(url, init, token, method, path);
   if (res.status === 401) {
     recordClientEvent("auth.unauthorized_retry", { method, path });
+    let retryToken: string;
     try {
-      const retryToken = await refreshSession();
-      const retryRes = await fetch(url, withBearer(init, retryToken));
-      if (!retryRes.ok && shouldLogStatus(retryRes.status, options)) {
-        recordApiError({
-          endpoint: url,
-          status: retryRes.status,
-          code: "AUTH_RETRY_ERROR",
-          message: "Retry request failed",
-          requestId: extractRequestId(retryRes.headers),
-        });
-        recordClientEvent("auth.retry_error", {
-          method,
-          path,
-          status: retryRes.status,
-          requestId: extractRequestId(retryRes.headers),
-        });
+      retryToken = await refreshSession();
+    } catch (error) {
+      if (isRefreshSessionRejected(error)) {
+        recordClientEvent("auth.session_expired", { method, path });
+        rejectExpiredSession("Session expired");
       }
-      return retryRes;
-    } catch {
-      useAuthStore.getState().setSignedOut();
+      throw error;
+    }
+    const retryRes = await fetchAuthed(url, init, retryToken, method, path);
+    if (!retryRes.ok && shouldLogStatus(retryRes.status, options)) {
       recordApiError({
         endpoint: url,
-        status: 401,
-        code: "SESSION_EXPIRED",
-        message: "Session expired",
+        status: retryRes.status,
+        code: "AUTH_RETRY_ERROR",
+        message: "Retry request failed",
+        requestId: extractRequestId(retryRes.headers),
+      });
+      recordClientEvent("auth.retry_error", {
+        method,
+        path,
+        status: retryRes.status,
+        requestId: extractRequestId(retryRes.headers),
       });
-      recordClientEvent("auth.session_expired", { method, path });
-      throw new ApiError("Session expired", 401);
     }
+    return retryRes;
   }
   if (!res.ok && shouldLogStatus(res.status, options)) {
     recordApiError({
diff --git a/apps/web/src/lib/blocked-content.ts b/apps/web/src/lib/blocked-content.ts
new file mode 100644
index 0000000..e17d608
--- /dev/null
+++ b/apps/web/src/lib/blocked-content.ts
@@ -0,0 +1,130 @@
+import { normalizeBlockedKeyword, titleMatchesBlockedKeyword } from "./blocked-keyword-filter";
+
+export type BlockedChannelIdentity = {
+  url?: string | null;
+  name?: string | null;
+};
+
+export type BlockableVideo = BlockedChannelIdentity & {
+  id?: string | null;
+  title?: string | null;
+  channelUrl?: string | null;
+  channelName?: string | null;
+};
+
+type BlockedItem = {
+  url: string;
+  name?: string | null;
+};
+
+const YOUTUBE_HOSTS = new Set([
+  "youtube.com",
+  "www.youtube.com",
+  "m.youtube.com",
+  "music.youtube.com",
+]);
+
+function youtubeVideoId(url: URL): string | null {
+  if (url.hostname.toLowerCase() === "youtu.be") return url.pathname.split("/")[1] || null;
+  if (!YOUTUBE_HOSTS.has(url.hostname.toLowerCase())) return null;
+  const queryId = url.searchParams.get("v");
+  if (queryId) return queryId;
+  const [kind, id] = url.pathname.split("/").filter(Boolean);
+  return kind && ["embed", "live", "shorts"].includes(kind.toLowerCase()) ? (id ?? null) : null;
+}
+
+export function normalizeBlockedContentUrl(value: string | null | undefined): string {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed) return "";
+  try {
+    const url = new URL(trimmed);
+    const videoId = youtubeVideoId(url);
+    if (videoId) return `youtube:video:${videoId}`;
+    const hostname = YOUTUBE_HOSTS.has(url.hostname.toLowerCase())
+      ? "youtube.com"
+      : url.hostname.toLowerCase();
+    const port = url.port ? `:${url.port}` : "";
+    const path = url.pathname.replace(/\/+$/, "") || "/";
+    return `${hostname}${port}${path}`;
+  } catch {
+    return trimmed.replace(/\/+$/, "");
+  }
+}
+
+function normalizeName(value: string | null | undefined): string {
+  return (value ?? "").normalize("NFKC").trim().toLowerCase();
+}
+
+export function createBlockedContentMatcher(
+  channels: BlockedItem[],
+  videos: BlockedItem[],
+  keywords: string[],
+) {
+  const channelsByUrl = new Map<string, BlockedItem>();
+  const channelsByName = new Map<string, BlockedItem>();
+  const videosByUrl = new Map<string, BlockedItem>();
+  for (const item of channels) {
+    const url = normalizeBlockedContentUrl(item.url);
+    const name = normalizeName(item.name);
+    if (url) channelsByUrl.set(url, item);
+    if (name) channelsByName.set(name, item);
+  }
+  for (const item of videos) {
+    const url = normalizeBlockedContentUrl(item.url);
+    if (url) videosByUrl.set(url, item);
+  }
+  const channelUrls = new Set(channelsByUrl.keys());
+  const videoUrls = new Set(videosByUrl.keys());
+  const normalizedKeywords = keywords.map(normalizeBlockedKeyword).filter(Boolean);
+
+  function findBlockedChannel(channel: BlockedChannelIdentity): BlockedItem | undefined {
+    const url = normalizeBlockedContentUrl(channel.url);
+    const name = normalizeName(channel.name);
+    return (
+      (url ? channelsByUrl.get(url) : undefined) ?? (name ? channelsByName.get(name) : undefined)
+    );
+  }
+
+  function isChannelBlocked(channel: BlockedChannelIdentity): boolean {
+    return findBlockedChannel(channel) !== undefined;
+  }
+
+  function findBlockedVideo(video: Pick<BlockableVideo, "id" | "url">): BlockedItem | undefined {
+    const candidates = new Set(
+      [video.url, video.id].map(normalizeBlockedContentUrl).filter((url) => url.length > 0),
+    );
+    for (const candidate of candidates) {
+      const item = videosByUrl.get(candidate);
+      if (item) return item;
+    }
+    return undefined;
+  }
+
+  function isVideoExplicitlyBlocked(video: Pick<BlockableVideo, "id" | "url">): boolean {
+    return findBlockedVideo(video) !== undefined;
+  }
+
+  function isVideoBlocked(video: BlockableVideo): boolean {
+    return (
+      isVideoExplicitlyBlocked(video) ||
+      isChannelBlocked({ url: video.channelUrl, name: video.channelName }) ||
+      titleMatchesBlockedKeyword(video.title ?? "", normalizedKeywords)
+    );
+  }
+
+  function filterVideos<T extends BlockableVideo>(items: T[]): T[] {
+    return items.filter((item) => !isVideoBlocked(item));
+  }
+
+  return {
+    channelUrls,
+    normalizedKeywords,
+    videoUrls,
+    filterVideos,
+    findBlockedChannel,
+    findBlockedVideo,
+    isChannelBlocked,
+    isVideoBlocked,
+    isVideoExplicitlyBlocked,
+  };
+}
diff --git a/apps/web/src/lib/copy-text.ts b/apps/web/src/lib/copy-text.ts
new file mode 100644
index 0000000..25bb191
--- /dev/null
+++ b/apps/web/src/lib/copy-text.ts
@@ -0,0 +1,46 @@
+export type CopyTextEnvironment = {
+  clipboard: Pick<Clipboard, "writeText"> | null;
+  document: Document | null;
+};
+
+function getBrowserEnvironment(): CopyTextEnvironment {
+  return {
+    clipboard: typeof navigator === "undefined" ? null : navigator.clipboard,
+    document: typeof document === "undefined" ? null : document,
+  };
+}
+
+export async function copyText(
+  value: string,
+  environment: CopyTextEnvironment = getBrowserEnvironment(),
+): Promise<boolean> {
+  if (environment.clipboard) {
+    try {
+      await environment.clipboard.writeText(value);
+      return true;
+    } catch {
+      // A non-secure context can expose the API while still rejecting writes.
+    }
+  }
+
+  const documentRef = environment.document;
+  if (!documentRef || typeof documentRef.execCommand !== "function") return false;
+
+  const textarea = documentRef.createElement("textarea");
+  textarea.value = value;
+  textarea.readOnly = true;
+  textarea.style.position = "fixed";
+  textarea.style.opacity = "0";
+  textarea.style.pointerEvents = "none";
+  documentRef.body.appendChild(textarea);
+  textarea.focus();
+  textarea.select();
+
+  try {
+    return documentRef.execCommand("copy");
+  } catch {
+    return false;
+  } finally {
+    textarea.remove();
+  }
+}
diff --git a/apps/web/src/lib/debug-console.ts b/apps/web/src/lib/debug-console.ts
index 7590e47..00995f9 100644
--- a/apps/web/src/lib/debug-console.ts
+++ b/apps/web/src/lib/debug-console.ts
@@ -4,8 +4,12 @@ type DebugDetails = Record<string, string | number | boolean | null | undefined>
 
 function enabled(): boolean {
   if (import.meta.env.DEV) return true;
-  if (typeof window === "undefined") return false;
-  return window.localStorage.getItem("typetype-debug-console") === "1";
+  if (typeof window === "undefined" || typeof window.localStorage === "undefined") return false;
+  try {
+    return window.localStorage.getItem("typetype-debug-console") === "1";
+  } catch {
+    return false;
+  }
 }
 
 function sanitizeDetails(details: DebugDetails | undefined): DebugDetails | undefined {
diff --git a/apps/web/src/lib/proxy.ts b/apps/web/src/lib/proxy.ts
index 0158085..a86d620 100644
--- a/apps/web/src/lib/proxy.ts
+++ b/apps/web/src/lib/proxy.ts
@@ -54,12 +54,40 @@ export function proxyImage(url: string): string {
   return proxyUrl(normalized);
 }
 
-export function toProxiedVttUrl(url: string): string {
+export function toSubtitleVttUrl(
+  url: string,
+  languageTag: string,
+  isAutoGenerated: boolean,
+): string {
   const parsed = new URL(url);
-  parsed.searchParams.set("fmt", "vtt");
   const youtubeTimedText =
-    (parsed.hostname === "youtube.com" || parsed.hostname === "www.youtube.com") &&
+    (parsed.hostname === "youtube.com" || parsed.hostname.endsWith(".youtube.com")) &&
     parsed.pathname === "/api/timedtext";
-  if (youtubeTimedText) return parsed.toString();
+  if (youtubeTimedText) return youtubeSubtitleUrl(parsed, languageTag, isAutoGenerated);
+  parsed.searchParams.set("fmt", "vtt");
   return proxyUrl(parsed.toString());
 }
+
+function youtubeSubtitleUrl(timedText: URL, languageTag: string, isAutoGenerated: boolean): string {
+  const videoId = timedText.searchParams.get("v")?.trim() ?? "";
+  const sourceLanguage = timedText.searchParams.get("lang")?.trim() ?? "";
+  const translation = timedText.searchParams.get("tlang")?.trim() ?? "";
+  const language = languageTag.trim() || translation || sourceLanguage;
+  if (!/^[A-Za-z0-9_-]{11}$/.test(videoId) || !language) {
+    throw new Error("Invalid YouTube subtitle track");
+  }
+  const auto =
+    isAutoGenerated ||
+    timedText.searchParams.get("kind") === "asr" ||
+    timedText.searchParams.get("vssId")?.startsWith("a.") === true;
+  const params = new URLSearchParams({
+    language,
+    variant: auto ? "auto" : "manual",
+    format: "vtt",
+  });
+  if (sourceLanguage) params.set("sourceLanguage", sourceLanguage);
+  if (translation) params.set("translation", translation);
+  const name = timedText.searchParams.get("name")?.trim();
+  if (name) params.set("name", name);
+  return `${absoluteBase()}/subtitles/youtube/${encodeURIComponent(videoId)}?${params}`;
+}
diff --git a/apps/web/src/lib/sabr-vidstack-loader.ts b/apps/web/src/lib/sabr-vidstack-loader.ts
index 0cdc409..5f95f62 100644
--- a/apps/web/src/lib/sabr-vidstack-loader.ts
+++ b/apps/web/src/lib/sabr-vidstack-loader.ts
@@ -1,4 +1,4 @@
-import { requestSabrVidstackPlayback } from "./sabr-vidstack-bridge";
+import { bindSabrVideoProvider } from "./sabr-vidstack-provider";
 import {
   type MediaContext,
   type MediaProviderLoader,
@@ -37,11 +37,7 @@ class SabrVideoProviderLoader implements MediaProviderLoader<VideoProvider> {
 
   async load(ctx: MediaContext): Promise<VideoProvider> {
     const provider = await this.videoLoader.load(ctx);
-    provider.loadSource = async () => undefined;
-    provider.play = () => requestSabrVidstackPlayback(provider.video, true);
-    provider.pause = () => requestSabrVidstackPlayback(provider.video, false);
-    provider.setCurrentTime = () => undefined;
-    return provider;
+    return bindSabrVideoProvider(provider);
   }
 }
 
diff --git a/apps/web/src/lib/sabr-vidstack-provider.ts b/apps/web/src/lib/sabr-vidstack-provider.ts
new file mode 100644
index 0000000..b9ff623
--- /dev/null
+++ b/apps/web/src/lib/sabr-vidstack-provider.ts
@@ -0,0 +1,12 @@
+import { requestSabrSeek, requestSabrVidstackPlayback } from "./sabr-vidstack-bridge";
+import type { VideoProvider } from "./vidstack";
+
+export function bindSabrVideoProvider(provider: VideoProvider): VideoProvider {
+  provider.loadSource = async () => undefined;
+  provider.play = () => requestSabrVidstackPlayback(provider.video, true);
+  provider.pause = () => requestSabrVidstackPlayback(provider.video, false);
+  provider.setCurrentTime = (time) => {
+    requestSabrSeek(provider.video, time);
+  };
+  return provider;
+}
diff --git a/apps/web/src/lib/search-filter-selection.ts b/apps/web/src/lib/search-filter-selection.ts
new file mode 100644
index 0000000..4f10abd
--- /dev/null
+++ b/apps/web/src/lib/search-filter-selection.ts
@@ -0,0 +1,86 @@
+import type { SearchFilterGroup, SearchFilterOption, SearchFiltersResponse } from "../types/api";
+
+const LABELS: Record<string, string> = {
+  sortby: "Sort by",
+  upload_date: "Upload date",
+  sort_relevance: "Relevance",
+  sort_rating: "Rating",
+  sort_view: "View count",
+  past_hour: "Past hour",
+  past_day: "Today",
+  past_week: "This week",
+  past_month: "This month",
+  past_year: "This year",
+  short_video: "Short",
+  long_video: "Long",
+  Ccommons: "Creative Commons",
+  Hdr: "HDR",
+  "3d": "3D",
+  "4k": "4K",
+};
+
+export function searchFilterLabel(raw: string): string {
+  const afterColon = raw.includes(":") ? raw.slice(raw.indexOf(":") + 1) : raw;
+  const value = afterColon.trim();
+  if (LABELS[value]) return LABELS[value];
+  return value
+    .split(/[_\s]+/)
+    .filter(Boolean)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(" ");
+}
+
+export function searchFilterGroups(filters: SearchFiltersResponse): SearchFilterGroup[] {
+  if (filters.filterGroups && filters.filterGroups.length > 0) return filters.filterGroups;
+  if (filters.sortFilters.length === 0) return [];
+  const hasDefault = filters.sortFilters.some((option) => option.isDefault);
+  return [
+    {
+      key: "legacy-sort",
+      label: "Sort by",
+      multiSelect: false,
+      options: filters.sortFilters.map((option, index) => ({
+        ...option,
+        isDefault: option.isDefault ?? (!hasDefault && index === 0),
+      })),
+    },
+  ];
+}
+
+export function sanitizeSearchFilters(
+  groups: readonly SearchFilterGroup[],
+  selected: readonly string[],
+): string[] {
+  const requested = new Set(selected);
+  return groups.flatMap((group) => {
+    const matches = group.options.filter(
+      (option) => requested.has(option.value) && !option.isDefault,
+    );
+    return (group.multiSelect ? matches : matches.slice(0, 1)).map((option) => option.value);
+  });
+}
+
+export function toggleSearchFilter(
+  groups: readonly SearchFilterGroup[],
+  selected: readonly string[],
+  groupKey: string,
+  option: SearchFilterOption,
+): string[] {
+  const group = groups.find((candidate) => candidate.key === groupKey);
+  if (!group) return sanitizeSearchFilters(groups, selected);
+  const groupValues = new Set(group.options.map((candidate) => candidate.value));
+  const next = selected.filter((value) => !groupValues.has(value));
+  if (group.multiSelect) {
+    next.push(...selected.filter((value) => groupValues.has(value) && value !== option.value));
+  }
+  if (!option.isDefault && !selected.includes(option.value)) next.push(option.value);
+  return sanitizeSearchFilters(groups, next);
+}
+
+export function activeSearchFilterOptions(
+  groups: readonly SearchFilterGroup[],
+  selected: readonly string[],
+): SearchFilterOption[] {
+  const values = new Set(sanitizeSearchFilters(groups, selected));
+  return groups.flatMap((group) => group.options.filter((option) => values.has(option.value)));
+}
diff --git a/apps/web/src/lib/stream-request.ts b/apps/web/src/lib/stream-request.ts
index 5f541a6..f90b8b1 100644
--- a/apps/web/src/lib/stream-request.ts
+++ b/apps/web/src/lib/stream-request.ts
@@ -22,13 +22,17 @@ function providerStreamPath(provider: ReturnType<typeof detectProvider>) {
 export function streamQueryKey(
   url: string,
   authenticated: boolean,
-): readonly ["stream", string, "auth" | "anon"] {
-  return ["stream", url, authenticated ? "auth" : "anon"];
+  ownerId?: string | null,
+): readonly ["stream", string, string] {
+  const scope = authenticated && ownerId ? `auth:${ownerId}` : authenticated ? "auth" : "anon";
+  return ["stream", url, scope];
 }
 
 export function sabrBootstrapQueryKey(
   url: string,
   authenticated: boolean,
-): readonly ["stream-bootstrap", string, "auth" | "anon"] {
-  return ["stream-bootstrap", url, authenticated ? "auth" : "anon"];
+  ownerId?: string | null,
+): readonly ["stream-bootstrap", string, string] {
+  const scope = authenticated && ownerId ? `auth:${ownerId}` : authenticated ? "auth" : "anon";
+  return ["stream-bootstrap", url, scope];
 }
diff --git a/apps/web/src/routes/embed_.$videoId.tsx b/apps/web/src/routes/embed_.$videoId.tsx
index 7684330..201d765 100644
--- a/apps/web/src/routes/embed_.$videoId.tsx
+++ b/apps/web/src/routes/embed_.$videoId.tsx
@@ -46,7 +46,7 @@ function EmbedPage() {
     isGuest,
     settingsReady: false,
   });
-  const { settings, settingsReady } = useSettings({
+  const { settingsReady } = useSettings({
     forceAnonymous: !accessWithoutSettings.sessionEnabled,
   });
   const access = resolveEmbedAccess({
@@ -57,9 +57,7 @@ function EmbedPage() {
     isGuest,
     settingsReady,
   });
-  const useAuthenticatedStream =
-    access.sessionEnabled &&
-    (settings.accessMode === "allow_list" || instance?.guestAllowed === false);
+  const useAuthenticatedStream = access.sessionEnabled;
   const streamQuery = useStream(sourceUrl, useAuthenticatedStream, access.streamEnabled);
   const bootstrap = useSabrBootstrap(sourceUrl, useAuthenticatedStream, access.streamEnabled);
   const publicParam = toPublicWatchParam(sourceUrl);
diff --git a/apps/web/src/routes/history.tsx b/apps/web/src/routes/history.tsx
index b46e958..4f411f6 100644
--- a/apps/web/src/routes/history.tsx
+++ b/apps/web/src/routes/history.tsx
@@ -1,6 +1,6 @@
 import { useQuery } from "@tanstack/react-query";
 import { createFileRoute } from "@tanstack/react-router";
-import { useEffect, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import { ConfirmModal } from "../components/confirm-modal";
 import { HistoryCard } from "../components/history-card";
 import type { FilterState } from "../components/history-filter";
@@ -8,6 +8,7 @@ import { HistoryFilter } from "../components/history-filter";
 import { ScrollSentinel } from "../components/scroll-sentinel";
 import { Toast } from "../components/toast";
 import { useAuth } from "../hooks/use-auth";
+import { useBlockedFilter } from "../hooks/use-blocked-filter";
 import { useHistory } from "../hooks/use-history";
 import { fetchHistory } from "../lib/api-user";
 import type { HistoryItem } from "../types/user";
@@ -53,6 +54,7 @@ function rangeFromFilter(filter: FilterState | null): DateRange {
 
 function HistoryPage() {
   const { isAuthed } = useAuth();
+  const { filter: filterBlocked } = useBlockedFilter();
   const [searchQuery, setSearchQuery] = useState("");
   const [filter, setFilter] = useState<FilterState | null>(null);
   const [pendingRemoveItem, setPendingRemoveItem] = useState<HistoryItem | null>(null);
@@ -81,14 +83,17 @@ function HistoryPage() {
     staleTime: 30_000,
   });
 
-  const filtered = filter !== null ? dedupeByUrl(allItemsQuery.data?.items ?? []) : items;
-  const filteredTotal = filter !== null ? filtered.length : total;
+  const unblocked = useMemo(
+    () => filterBlocked(filter !== null ? dedupeByUrl(allItemsQuery.data?.items ?? []) : items),
+    [allItemsQuery.data?.items, filter, filterBlocked, items],
+  );
+  const filteredTotal = filter !== null ? unblocked.length : total;
 
   return (
     <div className="flex flex-col gap-6 lg:flex-row lg:items-start lg:gap-8">
       <div className="flex-1 min-w-0">
         <div className="grid grid-cols-1 gap-x-3 gap-y-2 sm:grid-cols-2 sm:gap-x-4 sm:gap-y-8 md:grid-cols-3 lg:grid-cols-4">
-          {filtered.map((item: HistoryItem) => (
+          {unblocked.map((item: HistoryItem) => (
             <HistoryCard key={item.id} item={item} onRemove={() => setPendingRemoveItem(item)} />
           ))}
         </div>
diff --git a/apps/web/src/routes/playlists.tsx b/apps/web/src/routes/playlists.tsx
index 2ffd9c2..bd97ce7 100644
--- a/apps/web/src/routes/playlists.tsx
+++ b/apps/web/src/routes/playlists.tsx
@@ -1,5 +1,5 @@
 import { createFileRoute } from "@tanstack/react-router";
-import { useEffect, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import { ConfirmModal } from "../components/confirm-modal";
 import { LibraryCollectionCard } from "../components/library-collection-card";
 import { PlaylistCard } from "../components/playlist-card";
@@ -8,6 +8,7 @@ import { PlaylistsEmptyState } from "../components/playlists-empty-state";
 import { PlaylistsPageHeader } from "../components/playlists-page-header";
 import { SavedPlaylistsSection } from "../components/saved-playlists-section";
 import { Toast } from "../components/toast";
+import { useBlockedFilter } from "../hooks/use-blocked-filter";
 import { useFavoriteStreams } from "../hooks/use-favorite-streams";
 import { usePlaylists } from "../hooks/use-playlists";
 import { useSavedPlaylists } from "../hooks/use-saved-playlists";
@@ -17,10 +18,21 @@ import type { SavedPlaylistItem } from "../types/playlist";
 function PlaylistsPage() {
   const { query, create, remove } = usePlaylists();
   const savedPlaylists = useSavedPlaylists();
-  const favorites = useFavoriteStreams({ limit: 1 });
+  const favorites = useFavoriteStreams();
   const watchLater = useWatchLaterStreams();
   const playlists = query.data ?? [];
-  const saved = savedPlaylists.items;
+  const { filter, isPlaylistBlocked } = useBlockedFilter();
+  const visibleFavorites = useMemo(() => filter(favorites.videos), [favorites.videos, filter]);
+  const visibleWatchLater = useMemo(() => filter(watchLater.videos), [filter, watchLater.videos]);
+  const visiblePlaylists = useMemo(
+    () =>
+      playlists.map((playlist) => {
+        const videos = filter(playlist.videos ?? []);
+        return { ...playlist, videos, videoCount: videos.length };
+      }),
+    [filter, playlists],
+  );
+  const saved = savedPlaylists.items.filter((playlist) => !isPlaylistBlocked(playlist));
   const [selectionMode, setSelectionMode] = useState(false);
   const [selectedIds, setSelectedIds] = useState<Set<string>>(new Set());
   const [confirmIds, setConfirmIds] = useState<string[] | null>(null);
@@ -70,7 +82,8 @@ function PlaylistsPage() {
       : confirmIds.length === 1
         ? `Delete "${playlists.find((p) => p.id === confirmIds[0])?.name ?? "this playlist"}"?`
         : `Delete ${confirmIds.length} playlists?`;
-  const hasLocalCollections = playlists.length > 0 || favorites.count > 0 || watchLater.count > 0;
+  const hasLocalCollections =
+    playlists.length > 0 || visibleFavorites.length > 0 || visibleWatchLater.length > 0;
 
   return (
     <div className="flex flex-col gap-6 pt-2 sm:pt-4 [animation:page-fade-in_0.2s_ease-out]">
@@ -91,16 +104,16 @@ function PlaylistsPage() {
           <LibraryCollectionCard
             kind="favorites"
             title="Favorites"
-            count={favorites.count}
-            thumbnail={favorites.videos[0]?.thumbnail}
+            count={visibleFavorites.length}
+            thumbnail={visibleFavorites[0]?.thumbnail}
           />
           <LibraryCollectionCard
             kind="watch-later"
             title="Watch later"
-            count={watchLater.count}
-            thumbnail={watchLater.videos[0]?.thumbnail}
+            count={visibleWatchLater.length}
+            thumbnail={visibleWatchLater[0]?.thumbnail}
           />
-          {playlists.map((playlist, index) => (
+          {visiblePlaylists.map((playlist, index) => (
             <div
               key={playlist.id}
               className="animate-card-pop-in"
diff --git a/apps/web/src/routes/playlists_.$id.tsx b/apps/web/src/routes/playlists_.$id.tsx
index 783151d..618976a 100644
--- a/apps/web/src/routes/playlists_.$id.tsx
+++ b/apps/web/src/routes/playlists_.$id.tsx
@@ -6,6 +6,7 @@ import { PlaylistActions } from "../components/playlist-actions";
 import { PlaylistGrid } from "../components/playlist-grid";
 import { PlaylistRenameModal } from "../components/playlist-rename-modal";
 import { PlaylistSortMenu } from "../components/playlist-sort-menu";
+import { useBlockedFilter } from "../hooks/use-blocked-filter";
 import { usePlaylist } from "../hooks/use-playlist";
 import { usePlaylists } from "../hooks/use-playlists";
 import { randomShuffleSeed, shuffleByKey } from "../lib/playlist-shuffle";
@@ -18,6 +19,7 @@ function PlaylistDetailPage() {
   const { id } = Route.useParams();
   const navigate = useNavigate();
   const { remove, removeVideo, rename, reorder } = usePlaylists();
+  const { filter } = useBlockedFilter();
   const { data: playlist, isPending } = usePlaylist(id);
   const [renaming, setRenaming] = useState(false);
   const [pendingRemove, setPendingRemove] = useState<PlaylistVideoItem | null>(null);
@@ -45,7 +47,8 @@ function PlaylistDetailPage() {
     );
   }
 
-  const videos = playlist.videos ?? [];
+  const allVideos = playlist.videos ?? [];
+  const videos = filter(allVideos);
   const count = videos.length;
   const sortedVideos = sortPlaylistVideos(videos, sortMode);
   const reorderable = sortMode === "manual";
@@ -116,7 +119,11 @@ function PlaylistDetailPage() {
       </div>
       {count === 0 ? (
         <div className="flex flex-col items-center justify-center gap-2 py-32 text-center">
-          <p className="text-fg-muted text-sm">No videos in this playlist yet.</p>
+          <p className="text-fg-muted text-sm">
+            {allVideos.length > 0
+              ? "All videos in this playlist are blocked."
+              : "No videos in this playlist yet."}
+          </p>
           <p className="text-fg-soft text-xs">
             Save videos from the watch page using the Save button.
           </p>
diff --git a/apps/web/src/routes/search.tsx b/apps/web/src/routes/search.tsx
index 26face6..29f01eb 100644
--- a/apps/web/src/routes/search.tsx
+++ b/apps/web/src/routes/search.tsx
@@ -11,15 +11,24 @@ import { useSearchFilters } from "../hooks/use-search-filters";
 import { useSettings } from "../hooks/use-settings";
 
 function SearchPage() {
-  const { q, service, contentFilter, sortFilter } = Route.useSearch();
+  const {
+    q,
+    service,
+    contentFilter,
+    filters: selectedFilters = [],
+    sortFilter,
+  } = Route.useSearch();
   const navigate = useNavigate();
-  const filters = useSearchFilters(service);
+  const filters = useSearchFilters(service, contentFilter);
+  const searchFilters = [...selectedFilters, ...(sortFilter ? [sortFilter] : [])].filter(
+    (value, index, values) => values.indexOf(value) === index,
+  );
   const { settings } = useSettings();
   const { data, isLoading, isFetchingNextPage, hasNextPage, fetchNextPage } = useSearch(
     q,
     service,
     contentFilter,
-    sortFilter,
+    searchFilters,
   );
   const { filter, isChannelBlocked, isPlaylistBlocked } = useBlockedFilter();
 
@@ -59,20 +68,23 @@ function SearchPage() {
   }
 
   function setContentFilter(value: string | undefined) {
-    navigate({ to: "/search", search: { q, service, contentFilter: value, sortFilter } });
+    navigate({ to: "/search", search: { q, service, contentFilter: value } });
   }
 
-  function setSortFilter(value: string | undefined) {
-    navigate({ to: "/search", search: { q, service, contentFilter, sortFilter: value } });
+  function setSearchFilters(values: string[]) {
+    navigate({
+      to: "/search",
+      search: { q, service, contentFilter, ...(values.length > 0 ? { filters: values } : {}) },
+    });
   }
 
   const filterBar = filters.data ? (
     <SearchFilterBar
       filters={filters.data}
       contentFilter={contentFilter}
-      sortFilter={sortFilter}
+      selectedFilters={searchFilters}
       onContentChange={setContentFilter}
-      onSortChange={setSortFilter}
+      onFiltersChange={setSearchFilters}
     />
   ) : null;
 
@@ -131,11 +143,19 @@ function SearchPage() {
 }
 
 export const Route = createFileRoute("/search")({
-  validateSearch: (search: Record<string, unknown>) => ({
-    q: typeof search.q === "string" ? search.q : "",
-    service: typeof search.service === "number" ? search.service : 0,
-    ...(typeof search.contentFilter === "string" ? { contentFilter: search.contentFilter } : {}),
-    ...(typeof search.sortFilter === "string" ? { sortFilter: search.sortFilter } : {}),
-  }),
+  validateSearch: (search: Record<string, unknown>) => {
+    const filters = Array.isArray(search.filters)
+      ? search.filters.filter((value): value is string => typeof value === "string")
+      : typeof search.filters === "string"
+        ? [search.filters]
+        : [];
+    return {
+      q: typeof search.q === "string" ? search.q : "",
+      service: typeof search.service === "number" ? search.service : 0,
+      ...(typeof search.contentFilter === "string" ? { contentFilter: search.contentFilter } : {}),
+      ...(filters.length > 0 ? { filters } : {}),
+      ...(typeof search.sortFilter === "string" ? { sortFilter: search.sortFilter } : {}),
+    };
+  },
   component: SearchPage,
 });
diff --git a/apps/web/src/routes/subscriptions_.channels.tsx b/apps/web/src/routes/subscriptions_.channels.tsx
index 7432092..f716eae 100644
--- a/apps/web/src/routes/subscriptions_.channels.tsx
+++ b/apps/web/src/routes/subscriptions_.channels.tsx
@@ -3,6 +3,7 @@ import { createFileRoute } from "@tanstack/react-router";
 import { SubscriptionChannelList } from "../components/subscription-channel-list";
 import { SubscriptionsHeader } from "../components/subscriptions-header";
 import { VideoGridSkeleton } from "../components/video-grid-skeleton";
+import { useBlockedFilter } from "../hooks/use-blocked-filter";
 import { SUBSCRIPTION_FEED_KEY } from "../hooks/use-subscription-feed";
 import { SUBSCRIPTIONS_KEY, useSubscriptions } from "../hooks/use-subscriptions";
 import { fetchSubscriptionFeed, fetchSubscriptions } from "../lib/api-user";
@@ -16,7 +17,10 @@ function nextSubscriptionPage(last: Awaited<ReturnType<typeof fetchSubscriptionF
 function SubscriptionChannelsPage() {
   const queryClient = useQueryClient();
   const { query } = useSubscriptions();
-  const subscriptions = query.data ?? [];
+  const { isChannelIdentityBlocked } = useBlockedFilter();
+  const subscriptions = (query.data ?? []).filter(
+    (item) => !isChannelIdentityBlocked({ url: item.channelUrl, name: item.name }),
+  );
 
   function prefetchChannels() {
     void queryClient.prefetchQuery({
diff --git a/apps/web/src/routes/watch.tsx b/apps/web/src/routes/watch.tsx
index c7ddd6a..e91ae3f 100644
--- a/apps/web/src/routes/watch.tsx
+++ b/apps/web/src/routes/watch.tsx
@@ -27,11 +27,10 @@ function WatchPage() {
   const sourceUrl = toWatchSourceUrl(v);
   const publicParam = toPublicWatchParam(sourceUrl);
   const { authReady, isAuthed } = useAuth();
-  const { data: instance, isPending: instancePending } = useInstance();
+  const { isPending: instancePending } = useInstance();
   const { settings, settingsReady } = useSettings();
   const navigationSnapshot = useWatchNavigationStore((state) => state.snapshot);
-  const useAuthenticatedStream =
-    isAuthed && (settings.accessMode === "allow_list" || instance?.guestAllowed === false);
+  const useAuthenticatedStream = isAuthed;
   const streamEnabled = authReady && !instancePending && (!isAuthed || settingsReady);
   const streamQuery = useStream(sourceUrl, useAuthenticatedStream, streamEnabled);
   const bootstrap = useSabrBootstrap(sourceUrl, useAuthenticatedStream, streamEnabled);
diff --git a/apps/web/src/styles/player-menu-overrides.css b/apps/web/src/styles/player-menu-overrides.css
index 0a95bf6..2260923 100644
--- a/apps/web/src/styles/player-menu-overrides.css
+++ b/apps/web/src/styles/player-menu-overrides.css
@@ -19,6 +19,13 @@
   --media-cue-bg: rgb(0 0 0 / var(--media-user-text-bg-opacity, 0.7));
 }
 
+.vds-captions [data-part="cue-display"] {
+  left: 50%;
+  right: auto;
+  transform: translateX(-50%);
+  text-align: center;
+}
+
 @media (pointer: coarse) {
   .vds-video-layout[data-lg] .vds-volume-slider {
     margin-left: var(--gap, 10px);
diff --git a/apps/web/src/styles/shorts-overrides.css b/apps/web/src/styles/shorts-overrides.css
index 8189c18..f7026a8 100644
--- a/apps/web/src/styles/shorts-overrides.css
+++ b/apps/web/src/styles/shorts-overrides.css
@@ -87,10 +87,3 @@
 .shorts-shell .typetype-shorts-layout {
   border-radius: inherit;
 }
-
-.shorts-shell .vds-captions [data-part="cue-display"] {
-  left: 50%;
-  right: auto;
-  transform: translateX(-50%);
-  text-align: center;
-}
diff --git a/apps/web/src/types/api.ts b/apps/web/src/types/api.ts
index 3199853..4690ab6 100644
--- a/apps/web/src/types/api.ts
+++ b/apps/web/src/types/api.ts
@@ -103,14 +103,23 @@ export type SearchPageResponse = {
   isCorrectedSearch: boolean;
 };
 
-type SearchFilterOption = {
+export type SearchFilterOption = {
   value: string;
   label: string;
+  isDefault?: boolean;
+};
+
+export type SearchFilterGroup = {
+  key: string;
+  label: string;
+  multiSelect: boolean;
+  options: SearchFilterOption[];
 };
 
 export type SearchFiltersResponse = {
   contentFilters: SearchFilterOption[];
   sortFilters: SearchFilterOption[];
+  filterGroups?: SearchFilterGroup[];
 };
 
 export type HomeRecommendationsResponse = {
diff --git a/apps/web/src/types/playlist.ts b/apps/web/src/types/playlist.ts
index c284ab8..34772c7 100644
--- a/apps/web/src/types/playlist.ts
+++ b/apps/web/src/types/playlist.ts
@@ -8,6 +8,7 @@ export type WatchPlaylistItem = {
   title: string;
   thumbnail: string;
   channelName?: string;
+  channelUrl?: string;
 };
 
 export type PublicPlaylistInfo = {
diff --git a/apps/web/tests/admin-user-avatar.test.ts b/apps/web/tests/admin-user-avatar.test.ts
new file mode 100644
index 0000000..c11d193
--- /dev/null
+++ b/apps/web/tests/admin-user-avatar.test.ts
@@ -0,0 +1,39 @@
+import { describe, expect, test } from "bun:test";
+import { getAdminUserAvatarUrl } from "../src/lib/admin-user-avatar";
+import { getOpenMojiUrl, pickOpenMojiCode } from "../src/lib/openmoji";
+import type { AuthUser } from "../src/types/auth";
+
+const user: AuthUser = {
+  id: "user-123",
+  email: "before@example.com",
+  name: "Example",
+  role: "user",
+  publicUsername: null,
+  bio: null,
+  avatarUrl: null,
+  avatarType: null,
+  avatarCode: null,
+  suspended: false,
+  verified: true,
+  accessMode: "unrestricted",
+  createdAt: 0,
+};
+
+describe("getAdminUserAvatarUrl", () => {
+  test("keeps the fallback avatar stable when the email changes", () => {
+    const before = getAdminUserAvatarUrl(user);
+    const after = getAdminUserAvatarUrl({ ...user, email: "after@example.com" });
+
+    expect(after).toBe(before);
+    expect(after).toBe(getOpenMojiUrl(pickOpenMojiCode(user.id)));
+  });
+
+  test("preserves configured emoji and custom avatars", () => {
+    expect(getAdminUserAvatarUrl({ ...user, avatarType: "emoji", avatarCode: "1F600" })).toBe(
+      getOpenMojiUrl("1F600"),
+    );
+    expect(
+      getAdminUserAvatarUrl({ ...user, avatarType: "custom", avatarUrl: "/avatar/custom/user" }),
+    ).toBe("/api/avatar/custom/user");
+  });
+});
diff --git a/apps/web/tests/api-version.test.ts b/apps/web/tests/api-version.test.ts
index e28f3be..c00a2bf 100644
--- a/apps/web/tests/api-version.test.ts
+++ b/apps/web/tests/api-version.test.ts
@@ -1,12 +1,14 @@
 import { describe, expect, test } from "bun:test";
 
-Object.defineProperty(globalThis, "localStorage", {
-  value: {
-    getItem: () => null,
-    setItem: () => undefined,
-    removeItem: () => undefined,
-  },
-});
+if (!("localStorage" in globalThis)) {
+  Object.defineProperty(globalThis, "localStorage", {
+    value: {
+      getItem: () => null,
+      setItem: () => undefined,
+      removeItem: () => undefined,
+    },
+  });
+}
 
 const { parseComponentVersion } = await import("../src/lib/api-version");
 
diff --git a/apps/web/tests/auth-session-refresh.test.ts b/apps/web/tests/auth-session-refresh.test.ts
new file mode 100644
index 0000000..f4a1e27
--- /dev/null
+++ b/apps/web/tests/auth-session-refresh.test.ts
@@ -0,0 +1,143 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+if (!("localStorage" in globalThis)) {
+  Object.defineProperty(globalThis, "localStorage", {
+    value: {
+      getItem: () => null,
+      setItem: () => undefined,
+      removeItem: () => undefined,
+    },
+  });
+}
+
+const { authed } = await import("../src/lib/authed");
+const { bootstrapSession } = await import("../src/lib/auth-session");
+const { useAuthStore } = await import("../src/stores/auth-store");
+
+const originalFetch = globalThis.fetch;
+const me = {
+  id: "user-1",
+  role: "USER" as const,
+  publicUsername: "tester",
+  bio: null,
+  avatarUrl: null,
+  avatarType: null,
+  avatarCode: null,
+};
+
+function jsonResponse(status: number, body: object): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+beforeEach(() => {
+  useAuthStore.getState().setSession("stale-token", me);
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  useAuthStore.getState().setSignedOut();
+});
+
+describe("session refresh failures", () => {
+  test("keeps the cached session when bootstrap refresh is temporarily unavailable", async () => {
+    globalThis.fetch = mock(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.endsWith("/auth/me")) return jsonResponse(401, { error: "Unauthorized" });
+      if (url.endsWith("/auth/refresh")) {
+        return jsonResponse(503, { error: "Temporarily unavailable" });
+      }
+      throw new Error(`Unexpected request: ${url}`);
+    });
+
+    await bootstrapSession();
+
+    expect(useAuthStore.getState()).toMatchObject({
+      token: "stale-token",
+      me,
+      status: "authenticated",
+    });
+  });
+
+  test("preserves the session and propagates a temporary refresh error", async () => {
+    globalThis.fetch = mock(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url === "/api/settings") return new Response(null, { status: 401 });
+      if (url.endsWith("/auth/refresh")) {
+        return jsonResponse(503, { error: "Temporarily unavailable" });
+      }
+      throw new Error(`Unexpected request: ${url}`);
+    });
+
+    await expect(authed("/api/settings")).rejects.toEqual(expect.objectContaining({ status: 503 }));
+    expect(useAuthStore.getState()).toMatchObject({
+      token: "stale-token",
+      me,
+      status: "authenticated",
+    });
+  });
+
+  test("preserves the session when the refresh request loses connectivity", async () => {
+    globalThis.fetch = mock(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url === "/api/settings") return new Response(null, { status: 401 });
+      if (url.endsWith("/auth/refresh")) throw new Error("Connection lost");
+      throw new Error(`Unexpected request: ${url}`);
+    });
+
+    await expect(authed("/api/settings")).rejects.toEqual(
+      expect.objectContaining({ message: "Connection lost" }),
+    );
+    expect(useAuthStore.getState()).toMatchObject({
+      token: "stale-token",
+      me,
+      status: "authenticated",
+    });
+  });
+
+  test("keeps the refreshed session when the retried request loses connectivity", async () => {
+    let settingsRequests = 0;
+    globalThis.fetch = mock(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url === "/api/settings") {
+        settingsRequests += 1;
+        if (settingsRequests === 1) return new Response(null, { status: 401 });
+        throw new Error("Connection lost after refresh");
+      }
+      if (url.endsWith("/auth/refresh")) {
+        return jsonResponse(200, { accessToken: "fresh-token" });
+      }
+      if (url.endsWith("/auth/me")) return jsonResponse(200, me);
+      throw new Error(`Unexpected request: ${url}`);
+    });
+
+    await expect(authed("/api/settings")).rejects.toEqual(
+      expect.objectContaining({ message: "Connection lost after refresh" }),
+    );
+    expect(useAuthStore.getState()).toMatchObject({
+      token: "fresh-token",
+      me,
+      status: "authenticated",
+    });
+  });
+
+  test("signs out only when the refresh session is rejected", async () => {
+    globalThis.fetch = mock(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url === "/api/settings") return new Response(null, { status: 401 });
+      if (url.endsWith("/auth/refresh")) return jsonResponse(401, { error: "Unauthorized" });
+      throw new Error(`Unexpected request: ${url}`);
+    });
+
+    await expect(authed("/api/settings")).rejects.toEqual(
+      expect.objectContaining({ status: 401, message: "Session expired" }),
+    );
+    expect(useAuthStore.getState()).toMatchObject({
+      token: null,
+      me: null,
+      status: "signed_out",
+    });
+  });
+});
diff --git a/apps/web/tests/blocked-content.test.ts b/apps/web/tests/blocked-content.test.ts
new file mode 100644
index 0000000..2e04904
--- /dev/null
+++ b/apps/web/tests/blocked-content.test.ts
@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import {
+  createBlockedContentMatcher,
+  normalizeBlockedContentUrl,
+} from "../src/lib/blocked-content";
+
+describe("blocked content matching", () => {
+  test("treats equivalent YouTube video URLs as the same video", () => {
+    const matcher = createBlockedContentMatcher(
+      [],
+      [{ url: "https://www.youtube.com/watch?v=AbC_123-xyZ" }],
+      [],
+    );
+
+    expect(matcher.isVideoExplicitlyBlocked({ id: "https://youtu.be/AbC_123-xyZ?t=12" })).toBe(
+      true,
+    );
+    expect(
+      matcher.isVideoExplicitlyBlocked({ url: "https://m.youtube.com/shorts/AbC_123-xyZ" }),
+    ).toBe(true);
+  });
+
+  test("normalizes YouTube channel hosts and ignores URL decorations", () => {
+    expect(normalizeBlockedContentUrl("http://www.youtube.com/@Example/?view=0#top")).toBe(
+      "youtube.com/@Example",
+    );
+  });
+
+  test("matches blocked channels by canonical URL or normalized name", () => {
+    const matcher = createBlockedContentMatcher(
+      [{ url: "https://www.youtube.com/@Example", name: "Ｔｅｓｔ Channel" }],
+      [],
+      [],
+    );
+
+    expect(matcher.isChannelBlocked({ url: "https://m.youtube.com/@Example/" })).toBe(true);
+    expect(matcher.isChannelBlocked({ name: "test channel" })).toBe(true);
+  });
+
+  test("removes blocked videos, channels, and keywords from ordered candidates", () => {
+    const matcher = createBlockedContentMatcher(
+      [{ url: "https://youtube.com/@blocked", name: "Blocked" }],
+      [{ url: "https://youtube.com/watch?v=blocked-video" }],
+      ["spoiler"],
+    );
+    const candidates = [
+      { id: "https://youtube.com/watch?v=blocked-video", title: "One" },
+      {
+        id: "https://youtube.com/watch?v=blocked-channel",
+        title: "Two",
+        channelUrl: "https://www.youtube.com/@blocked",
+      },
+      { id: "https://youtube.com/watch?v=blocked-title", title: "A spoiler inside" },
+      { id: "https://youtube.com/watch?v=visible", title: "Visible" },
+    ];
+
+    expect(matcher.filterVideos(candidates).map((item) => item.title)).toEqual(["Visible"]);
+  });
+});
diff --git a/apps/web/tests/copy-text.test.ts b/apps/web/tests/copy-text.test.ts
new file mode 100644
index 0000000..8aea7be
--- /dev/null
+++ b/apps/web/tests/copy-text.test.ts
@@ -0,0 +1,70 @@
+import { describe, expect, mock, test } from "bun:test";
+import { type CopyTextEnvironment, copyText } from "../src/lib/copy-text";
+
+function fallbackEnvironment(copyResult = true) {
+  const remove = mock(() => {});
+  const textarea = {
+    value: "",
+    readOnly: false,
+    style: {} as CSSStyleDeclaration,
+    focus: mock(() => {}),
+    select: mock(() => {}),
+    remove,
+  } as unknown as HTMLTextAreaElement;
+  const appendChild = mock(() => textarea);
+  const execCommand = mock(() => copyResult);
+  const documentRef = {
+    body: { appendChild },
+    createElement: mock(() => textarea),
+    execCommand,
+  } as unknown as Document;
+
+  return { documentRef, textarea, appendChild, execCommand, remove };
+}
+
+describe("copyText", () => {
+  test("uses the Clipboard API when it is available", async () => {
+    const writeText = mock(async () => {});
+    const environment: CopyTextEnvironment = {
+      clipboard: { writeText },
+      document: null,
+    };
+
+    expect(await copyText("reset-token", environment)).toBe(true);
+    expect(writeText).toHaveBeenCalledWith("reset-token");
+  });
+
+  test("falls back when the Clipboard API is unavailable", async () => {
+    const fallback = fallbackEnvironment();
+
+    expect(
+      await copyText("reset-token", {
+        clipboard: null,
+        document: fallback.documentRef,
+      }),
+    ).toBe(true);
+    expect(fallback.textarea.value).toBe("reset-token");
+    expect(fallback.appendChild).toHaveBeenCalledTimes(1);
+    expect(fallback.execCommand).toHaveBeenCalledWith("copy");
+    expect(fallback.remove).toHaveBeenCalledTimes(1);
+  });
+
+  test("falls back after a Clipboard API rejection", async () => {
+    const fallback = fallbackEnvironment();
+    const writeText = mock(async () => {
+      throw new Error("clipboard denied");
+    });
+
+    expect(
+      await copyText("reset-token", {
+        clipboard: { writeText },
+        document: fallback.documentRef,
+      }),
+    ).toBe(true);
+    expect(fallback.execCommand).toHaveBeenCalledWith("copy");
+  });
+
+  test("reports failure when no copy mechanism is available", async () => {
+    expect(await copyText("reset-token", { clipboard: null, document: null })).toBe(false);
+  });
+});
diff --git a/apps/web/tests/sabr-vidstack-provider.test.ts b/apps/web/tests/sabr-vidstack-provider.test.ts
new file mode 100644
index 0000000..019b7b4
--- /dev/null
+++ b/apps/web/tests/sabr-vidstack-provider.test.ts
@@ -0,0 +1,22 @@
+import { expect, test } from "bun:test";
+import { registerSabrVidstackControls } from "../src/lib/sabr-vidstack-bridge";
+import { bindSabrVideoProvider } from "../src/lib/sabr-vidstack-provider";
+
+test("routes Vidstack provider seeks through SABR controls", () => {
+  const positions: number[] = [];
+  const video = { autoplay: false, pause: () => {} } as HTMLVideoElement;
+  const provider = { video } as Parameters<typeof bindSabrVideoProvider>[0];
+  const unregister = registerSabrVidstackControls(video, {
+    play: async () => {},
+    pause: () => {},
+    seek: (seconds) => positions.push(seconds),
+  });
+
+  try {
+    bindSabrVideoProvider(provider).setCurrentTime(93.5);
+
+    expect(positions).toEqual([93.5]);
+  } finally {
+    unregister();
+  }
+});
diff --git a/apps/web/tests/search-filter-selection.test.ts b/apps/web/tests/search-filter-selection.test.ts
new file mode 100644
index 0000000..4b433d1
--- /dev/null
+++ b/apps/web/tests/search-filter-selection.test.ts
@@ -0,0 +1,92 @@
+import { describe, expect, test } from "bun:test";
+import {
+  activeSearchFilterOptions,
+  sanitizeSearchFilters,
+  searchFilterGroups,
+  searchFilterLabel,
+  toggleSearchFilter,
+} from "../src/lib/search-filter-selection";
+import type { SearchFilterGroup } from "../src/types/api";
+
+const groups: SearchFilterGroup[] = [
+  {
+    key: "sort",
+    label: "sortby",
+    multiSelect: false,
+    options: [
+      { value: "relevance", label: "sort_relevance", isDefault: true },
+      { value: "views", label: "sort_view" },
+      { value: "rating", label: "sort_rating" },
+    ],
+  },
+  {
+    key: "features",
+    label: "features",
+    multiSelect: true,
+    options: [
+      { value: "hd", label: "HD" },
+      { value: "captions", label: "Subtitles" },
+    ],
+  },
+];
+
+function option(groupKey: string, value: string) {
+  const match = groups
+    .find((group) => group.key === groupKey)
+    ?.options.find((candidate) => candidate.value === value);
+  if (!match) throw new Error(`Missing ${groupKey} option ${value}`);
+  return match;
+}
+
+describe("search filter selection", () => {
+  test("keeps one exclusive value and multiple feature values", () => {
+    expect(sanitizeSearchFilters(groups, ["views", "rating", "hd", "captions"])).toEqual([
+      "views",
+      "hd",
+      "captions",
+    ]);
+  });
+
+  test("replaces exclusive filters without changing other groups", () => {
+    expect(toggleSearchFilter(groups, ["views", "hd"], "sort", option("sort", "rating"))).toEqual([
+      "rating",
+      "hd",
+    ]);
+  });
+
+  test("selecting a default removes the group from the URL", () => {
+    expect(
+      toggleSearchFilter(groups, ["views", "hd"], "sort", option("sort", "relevance")),
+    ).toEqual(["hd"]);
+  });
+
+  test("toggles multi-select filters independently", () => {
+    expect(
+      toggleSearchFilter(groups, ["views", "hd"], "features", option("features", "captions")),
+    ).toEqual(["views", "hd", "captions"]);
+    expect(
+      toggleSearchFilter(groups, ["views", "hd"], "features", option("features", "hd")),
+    ).toEqual(["views"]);
+  });
+
+  test("falls back to the legacy flat filter response", () => {
+    expect(
+      searchFilterGroups({ contentFilters: [], sortFilters: [{ value: "views", label: "Views" }] }),
+    ).toEqual([
+      {
+        key: "legacy-sort",
+        label: "Sort by",
+        multiSelect: false,
+        options: [{ value: "views", label: "Views", isDefault: true }],
+      },
+    ]);
+  });
+
+  test("returns active options and human labels", () => {
+    expect(
+      activeSearchFilterOptions(groups, ["views", "hd"]).map((option) => option.value),
+    ).toEqual(["views", "hd"]);
+    expect(searchFilterLabel("upload_date")).toBe("Upload date");
+    expect(searchFilterLabel("sort_view")).toBe("View count");
+  });
+});
diff --git a/apps/web/tests/subtitle-track-utils.test.ts b/apps/web/tests/subtitle-track-utils.test.ts
index 2b96098..333faba 100644
--- a/apps/web/tests/subtitle-track-utils.test.ts
+++ b/apps/web/tests/subtitle-track-utils.test.ts
@@ -6,14 +6,14 @@ Object.assign(globalThis, { window: { location: { origin: "https://typetype.test
 test("uses caption variants instead of numeric duplicate language labels", () => {
   const tracks = buildSafeSubtitleTracks([
     {
-      url: "https://www.youtube.com/api/timedtext?lang=en&name=CC1",
+      url: "https://www.youtube.com/api/timedtext?v=abcdefghijk&lang=en&name=CC1&expire=123&sig=secret",
       mimeType: "text/vtt",
       languageTag: "en",
       displayLanguageName: "English",
       isAutoGenerated: false,
     },
     {
-      url: "https://www.youtube.com/api/timedtext?lang=en&name=DTVCC1",
+      url: "https://www.youtube.com/api/timedtext?v=abcdefghijk&lang=en&name=DTVCC1&expire=456&sig=secret",
       mimeType: "text/vtt",
       languageTag: "en",
       displayLanguageName: "English",
@@ -22,6 +22,46 @@ test("uses caption variants instead of numeric duplicate language labels", () =>
   ]);
 
   expect(tracks.map((track) => track.label)).toEqual(["English (CC1)", "English (DTVCC1)"]);
-  expect(tracks.every((track) => new URL(track.src).searchParams.get("fmt") === "vtt")).toBe(true);
-  expect(tracks.every((track) => new URL(track.src).hostname === "www.youtube.com")).toBe(true);
+  expect(tracks.every((track) => new URL(track.src).searchParams.get("format") === "vtt")).toBe(
+    true,
+  );
+  expect(tracks.every((track) => new URL(track.src).hostname === "typetype.test")).toBe(true);
+  expect(
+    tracks.every((track) => new URL(track.src).pathname === "/api/subtitles/youtube/abcdefghijk"),
+  ).toBe(true);
+  expect(tracks.every((track) => !track.src.includes("secret"))).toBe(true);
+});
+
+test("preserves generated and translated YouTube subtitle selection", () => {
+  const [track] = buildSafeSubtitleTracks([
+    {
+      url: "https://m.youtube.com/api/timedtext?v=abcdefghijk&lang=en&kind=asr&tlang=fr",
+      mimeType: "application/ttml+xml",
+      languageTag: "fr",
+      displayLanguageName: "French",
+      isAutoGenerated: false,
+    },
+  ]);
+
+  const src = new URL(track?.src ?? "");
+  expect(src.searchParams.get("language")).toBe("fr");
+  expect(src.searchParams.get("sourceLanguage")).toBe("en");
+  expect(src.searchParams.get("translation")).toBe("fr");
+  expect(src.searchParams.get("variant")).toBe("auto");
+});
+
+test("keeps non YouTube subtitle tracks on the generic proxy", () => {
+  const [track] = buildSafeSubtitleTracks([
+    {
+      url: "https://subtitles.example.test/captions.ttml",
+      mimeType: "application/ttml+xml",
+      languageTag: "en",
+      displayLanguageName: "English",
+      isAutoGenerated: false,
+    },
+  ]);
+
+  const src = new URL(track?.src ?? "");
+  expect(src.pathname).toBe("/api/proxy");
+  expect(src.searchParams.get("url")).toContain("fmt=vtt");
 });
diff --git a/bun.lock b/bun.lock
index 43d5ba2..7e65590 100644
--- a/bun.lock
+++ b/bun.lock
@@ -12,7 +12,7 @@
     },
     "apps/web": {
       "name": "@typetype/web",
-      "version": "1.3.1",
+      "version": "1.4.0",
       "dependencies": {
         "@tanstack/react-query": "^5.101.2",
         "@tanstack/react-router": "^1.170.17",
diff --git a/package.json b/package.json
index 610b9bb..a7776f6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typetype/frontend",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "devDependencies": {
     "@biomejs/biome": "^2.5.6",
     "knip": "^6.29.0",