test(views,layer): close the two polish-tail deep-review test gaps

UX-8 layerStack: add an integration test wired through the real useLayer
hook (popover document-listener + stamp) and a PlayerModal-shaped window
listener, driven by a real dispatched keydown. The popover close is wrapped
in flushSync so its layer is popped synchronously between the two listeners
-- the production mid-dispatch race -- making the escapeHandled stamp the
only thing that keeps the player from also closing. Mutation-checked:
removing the guard fails exactly this case.

SavedViews: cover feedCanSeedDefault's "yield to a bookmarked filter URL"
branch (a filter-bearing search string -> no seed) and the per-source
seededRef guard against the 60s refetch (a changed-list refetch re-runs the
seed effect; the guard blocks re-seed). The refetch test waits for the
changed list to reach the component so the effect has its chance to wrongly
re-fire. Both mutation-checked.

Frontend gate green: 464 vitest (+4). Backend untouched.

frontend/src/components/SavedViewsProvider.dom.test.tsx

@@ -46,6 +46,7 @@ import { SavedViewsProvider, useSavedViews } from "./SavedViewsProvider";
 import { api, setActiveAccount, type SavedView } from "../lib/api";
 import { LS, accountKey } from "../lib/storage";
 import { ACTIVE_ACCOUNT_KEY } from "../lib/activeAccount";
+import { qk } from "../lib/queryKeys";
 
 const ID = 7;
 const view = (over: Partial<SavedView>): SavedView => ({
@@ -58,12 +59,19 @@ const view = (over: Partial<SavedView>): SavedView => ({
 });
 
 function Probe() {
-  const { loading } = useSavedViews();
-  return <div data-testid="loading">{String(loading)}</div>;
+  const { loading, views } = useSavedViews();
+  return (
+    <div data-testid="loading" data-count={views.length}>
+      {String(loading)}
+    </div>
+  );
 }
 
 async function mountResolved(views: SavedView[]) {
-  vi.spyOn(api, "savedViews").mockResolvedValue(views);
+  // Fresh array + object copies per call, like a real fetch — so a refetch changes viewsQuery.data's
+  // identity and re-runs the seed effect (which is what makes the per-source guard actually load-bearing
+  // in the re-seed test; a shared reference would skip the effect and hide a missing guard).
+  vi.spyOn(api, "savedViews").mockImplementation(async () => views.map((v) => ({ ...v })));
   const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
   render(
     <QueryClientProvider client={qc}>
@@ -74,11 +82,15 @@ async function mountResolved(views: SavedView[]) {
   );
   // Wait for the query to resolve so the first-resolve effect has run.
   await waitFor(() => expect(screen.getByTestId("loading").textContent).toBe("false"));
+  return qc;
 }
 
 beforeEach(() => {
   localStorage.clear();
   sessionStorage.setItem(ACTIVE_ACCOUNT_KEY, String(ID));
+  // Reset the URL: feedCanSeedDefault reads window.location.search, and a stale ?sort= from a prior
+  // case would suppress seeding in the others.
+  window.history.replaceState({}, "", "/");
   h.page = "feed";
   h.setFeedFilters.mockClear();
   h.setPlexFilters.mockClear();
@@ -123,6 +135,46 @@ describe("SavedViewsProvider — default-view seeding on first resolve", () => {
     expect(h.setFeedFilters).not.toHaveBeenCalled();
   });
 
+  it("feed: does NOT seed when the URL carries filter params (a shared/bookmarked view wins)", async () => {
+    // A link like ?sort=oldest is an explicit filter the user arrived on; the starred default must not
+    // stomp it. feedCanSeedDefault() bails on hasFilterParams — plex ignores the URL, so this is feed-only.
+    window.history.replaceState({}, "", "/?sort=oldest");
+    await mountResolved([
+      view({ id: 2, is_default: true, filters: { scope: "all", show: "watched" } }),
+    ]);
+    expect(h.setFeedFilters).not.toHaveBeenCalled();
+  });
+
+  it("does NOT re-seed on a background refetch that returns a changed list (per-source one-shot guard)", async () => {
+    // The 60s refetch re-resolves the query; when it returns a CHANGED list (e.g. the user just added a
+    // view elsewhere) react-query hands down a new reference and the seed effect re-runs. seededRef must
+    // stop it re-applying the default over filters the user has since edited. (An identical refetch is
+    // deduped by structural sharing and never reaches the effect, so the changed list is the real test.)
+    const def = view({ id: 2, is_default: true, filters: { scope: "all", show: "watched" } });
+    let calls = 0;
+    vi.spyOn(api, "savedViews").mockImplementation(async () => {
+      calls += 1;
+      return calls === 1 ? [def] : [def, view({ id: 9, name: "added-later" })];
+    });
+    const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+    render(
+      <QueryClientProvider client={qc}>
+        <SavedViewsProvider>
+          <Probe />
+        </SavedViewsProvider>
+      </QueryClientProvider>,
+    );
+    await waitFor(() => expect(screen.getByTestId("loading").textContent).toBe("false"));
+    expect(h.setFeedFilters).toHaveBeenCalledTimes(1);
+    await act(async () => {
+      await qc.refetchQueries({ queryKey: qk.savedViews("feed") });
+    });
+    // Wait until the changed list has actually reached the component, so the seed effect has had its
+    // chance to (wrongly) re-fire — otherwise the assertion could win by racing ahead of the re-render.
+    await waitFor(() => expect(screen.getByTestId("loading").dataset.count).toBe("2"));
+    expect(h.setFeedFilters).toHaveBeenCalledTimes(1);
+  });
+
   it("plex: seeds the starred default into a fresh module (parity with the feed)", async () => {
     h.page = "plex";
     await mountResolved([view({ id: 3, is_default: true, filters: { genres: ["Action"] } })]);