diff --git a/src/App.css b/src/App.css
index 12675f8..570ace9 100644
--- a/src/App.css
+++ b/src/App.css
@@ -43,6 +43,39 @@
   margin: 0;
 }
 
+.view-navigation {
+  display: flex;
+  gap: 0.5rem;
+  max-width: 32rem;
+  margin: 0 auto 1.5rem;
+}
+
+.view-navigation button {
+  flex: 1;
+  padding: 0.625rem 0.75rem;
+  border: 1px solid #cbd2d9;
+  border-radius: 0.375rem;
+  background-color: #ffffff;
+  color: #243b53;
+  font: inherit;
+  font-weight: 600;
+}
+
+.view-navigation button:hover {
+  background-color: #edf2f7;
+}
+
+.view-navigation button[aria-pressed="true"] {
+  border-color: #2c3e50;
+  background-color: #2c3e50;
+  color: #ffffff;
+}
+
+.view-navigation button:focus-visible {
+  outline: 0.1875rem solid #2c3e50;
+  outline-offset: 0.125rem;
+}
+
 .book-viewer {
   max-width: 32rem;
   margin: 0 auto;
diff --git a/src/App.test.tsx b/src/App.test.tsx
index 4aa1baf..31b8555 100644
--- a/src/App.test.tsx
+++ b/src/App.test.tsx
@@ -49,6 +49,23 @@ describe("App", () => {
     expect(await screen.findByText(/No books found/)).toBeInTheDocument();
   });
 
+  it("switches between the library and favorites views", async () => {
+    const user = userEvent.setup();
+    withProviders(<App />);
+    await screen.findByRole("heading", { name: "A Wizard of Earthsea" });
+
+    await user.click(screen.getByRole("button", { name: "Favorites" }));
+    expect(screen.getByRole("button", { name: "Favorites" })).toHaveAttribute(
+      "aria-pressed",
+      "true",
+    );
+    expect(screen.queryByRole("region", { name: "Book viewer" })).not.toBeInTheDocument();
+
+    await user.click(screen.getByRole("button", { name: "Library" }));
+    expect(screen.getByRole("button", { name: "Library" })).toHaveAttribute("aria-pressed", "true");
+    expect(screen.getByRole("region", { name: "Book viewer" })).toBeInTheDocument();
+  });
+
   it("navigates to the next and previous book with the controls", async () => {
     const user = userEvent.setup();
     withProviders(<App />);
@@ -192,14 +209,24 @@ describe("App", () => {
   });
 
   it("saves, restores, and removes a favorite", async () => {
+    const user = userEvent.setup();
     const firstRender = withProviders(<App />);
     await screen.findByRole("heading", { name: "A Wizard of Earthsea" });
 
     fireEvent.click(screen.getByRole("button", { name: "Add A Wizard of Earthsea to favorites" }));
-    expect(localStorage.getItem("t19.favorites")).toBe(JSON.stringify(["/works/OL2"]));
+    expect(JSON.parse(localStorage.getItem("t19.favorites") ?? "[]")).toEqual([
+      {
+        key: "/works/OL2",
+        title: "A Wizard of Earthsea",
+        authors: ["Ursula K. Le Guin"],
+        firstPublishYear: 1968,
+        coverId: null,
+      },
+    ]);
 
     firstRender.unmount();
     withProviders(<App />);
+    await user.click(screen.getByRole("button", { name: "Favorites" }));
     await screen.findByRole("button", { name: "Remove A Wizard of Earthsea from favorites list" });
 
     fireEvent.click(
@@ -208,6 +235,58 @@ describe("App", () => {
     expect(localStorage.getItem("t19.favorites")).toBe(JSON.stringify([]));
   });
 
+  it("keeps favorites from different subjects together after reload", async () => {
+    server.use(
+      http.get("https://openlibrary.org/search.json", ({ request }) => {
+        const subject = new URL(request.url).searchParams.get("subject");
+        const docs =
+          subject === "mystery"
+            ? [
+                {
+                  key: "/works/OL4",
+                  title: "The Moonstone",
+                  author_name: ["Wilkie Collins"],
+                  first_publish_year: 1868,
+                  cover_i: 456,
+                },
+              ]
+            : [
+                {
+                  key: "/works/OL2",
+                  title: "A Wizard of Earthsea",
+                  author_name: ["Ursula K. Le Guin"],
+                  first_publish_year: 1968,
+                },
+              ];
+        return HttpResponse.json({ docs });
+      }),
+    );
+    const user = userEvent.setup();
+    const firstRender = withProviders(<App />);
+
+    await screen.findByRole("heading", { name: "A Wizard of Earthsea" });
+    await user.click(screen.getByRole("button", { name: "Add A Wizard of Earthsea to favorites" }));
+
+    await user.selectOptions(screen.getByRole("combobox", { name: "Subject" }), "mystery");
+    await screen.findByRole("heading", { name: "The Moonstone" });
+    await user.click(screen.getByRole("button", { name: "Add The Moonstone to favorites" }));
+    await user.click(screen.getByRole("button", { name: "Favorites" }));
+
+    expect(
+      screen.getByRole("heading", { name: "A Wizard of Earthsea", level: 3 }),
+    ).toBeInTheDocument();
+    expect(screen.getByRole("heading", { name: "The Moonstone", level: 3 })).toBeInTheDocument();
+
+    firstRender.unmount();
+    withProviders(<App />);
+    await user.click(screen.getByRole("button", { name: "Favorites" }));
+
+    expect(
+      await screen.findByRole("heading", { name: "A Wizard of Earthsea", level: 3 }),
+    ).toBeInTheDocument();
+    expect(screen.getByRole("heading", { name: "The Moonstone", level: 3 })).toBeInTheDocument();
+  });
+
   it("supports the complete library user flow without unnecessary requests", async () => {
     const user = userEvent.setup();
     withProviders(<App />);
@@ -229,7 +308,15 @@ describe("App", () => {
 
     await user.click(screen.getByRole("button", { name: "Add A Wizard of Earthsea to favorites" }));
 
-    expect(localStorage.getItem("t19.favorites")).toBe(JSON.stringify(["/works/OL2"]));
+    expect(JSON.parse(localStorage.getItem("t19.favorites") ?? "[]")).toEqual([
+      {
+        key: "/works/OL2",
+        title: "A Wizard of Earthsea",
+        authors: ["Ursula K. Le Guin"],
+        firstPublishYear: 1968,
+        coverId: null,
+      },
+    ]);
     expect(getSearchRequestCount()).toBe(2);
   });
 
diff --git a/src/App.tsx b/src/App.tsx
index ed9215b..e8b520d 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,4 +1,4 @@
-import { useState } from "react";
+import { useEffect, useState } from "react";
 import { BookCard } from "./components/BookCard";
 import { BookJumpList } from "./components/BookJumpList";
 import { NavigationControls } from "./components/NavigationControls";
@@ -12,6 +12,8 @@ import { SortSelect } from "./components/SortSelect";
 import { sortBooks } from "./utils/sortBooks";
 import "./App.css";
 
+type AppView = "library" | "favorites";
+
 function App() {
   const { subject, setSubject, sort, setSort } = usePreferences();
   const { books, isLoading, isError } = useBooks(subject);
@@ -19,10 +21,18 @@ function App() {
   const sortedBooks = sortBooks(books, sort);
 
   const [index, setIndex] = useState(0);
+  const [view, setView] = useState<AppView>("library");
   const safeIndex = sortedBooks.length > 0 ? Math.min(index, sortedBooks.length - 1) : 0;
   const current = sortedBooks[safeIndex];
 
-  const { favoriteKeys, toggleFavorite, removeFavorite } = useFavorites();
+  const { favoriteBooks, isFavorite, toggleFavorite, removeFavorite, updateFavoriteDetails } =
+    useFavorites();
+
+  useEffect(() => {
+    if (current !== undefined) {
+      updateFavoriteDetails(current);
+    }
+  }, [current, updateFavoriteDetails]);
 
   function handleSubjectChange(nextSubject: string) {
     setSubject(nextSubject);
@@ -41,37 +51,56 @@ function App() {
         <p>Browse reading material from OpenLibrary, one book at a time.</p>
       </header>
       <main className="app-main">
-        <div className="library-controls">
-          <SubjectFilter subject={subject} onSubjectChange={handleSubjectChange} />
-          <SortSelect sort={sort} onSortChange={handleSortChange} />
-        </div>
-        {isLoading && <p role="status">Loading books…</p>}
-        {isError && <p role="alert">Could not load books. Please try refreshing the page.</p>}
-        {!isLoading && !isError && books.length === 0 && (
-          <p>No books found for the subject “{subject}”.</p>
-        )}
-        {current && (
-          <section className="book-viewer" aria-label="Book viewer">
-            <BookCard
-              book={current}
-              isFavorite={favoriteKeys.includes(current.key)}
-              onFavoriteToggle={() => toggleFavorite(current.key)}
-            />
-            <NavigationControls
-              currentIndex={safeIndex}
-              totalCount={sortedBooks.length}
-              onPrevious={() => setIndex(Math.max(0, safeIndex - 1))}
-              onNext={() => setIndex(Math.min(sortedBooks.length - 1, safeIndex + 1))}
-            />
-            <BookJumpList
-              titles={sortedBooks.map((book) => book.title)}
-              currentIndex={safeIndex}
-              onSelect={setIndex}
-            />
-          </section>
-        )}
-        {!isLoading && !isError && (
-          <FavoritesView books={books} favoriteKeys={favoriteKeys} onRemove={removeFavorite} />
+        <nav className="view-navigation" aria-label="Library views">
+          <button
+            type="button"
+            aria-pressed={view === "library"}
+            onClick={() => setView("library")}
+          >
+            Library
+          </button>
+          <button
+            type="button"
+            aria-pressed={view === "favorites"}
+            onClick={() => setView("favorites")}
+          >
+            Favorites
+          </button>
+        </nav>
+        {view === "library" ? (
+          <>
+            <div className="library-controls">
+              <SubjectFilter subject={subject} onSubjectChange={handleSubjectChange} />
+              <SortSelect sort={sort} onSortChange={handleSortChange} />
+            </div>
+            {isLoading && <p role="status">Loading books…</p>}
+            {isError && <p role="alert">Could not load books. Please try refreshing the page.</p>}
+            {!isLoading && !isError && books.length === 0 && (
+              <p>No books found for the subject “{subject}”.</p>
+            )}
+            {current && (
+              <section className="book-viewer" aria-label="Book viewer">
+                <BookCard
+                  book={current}
+                  isFavorite={isFavorite(current.key)}
+                  onFavoriteToggle={() => toggleFavorite(current)}
+                />
+                <NavigationControls
+                  currentIndex={safeIndex}
+                  totalCount={sortedBooks.length}
+                  onPrevious={() => setIndex(Math.max(0, safeIndex - 1))}
+                  onNext={() => setIndex(Math.min(sortedBooks.length - 1, safeIndex + 1))}
+                />
+                <BookJumpList
+                  titles={sortedBooks.map((book) => book.title)}
+                  currentIndex={safeIndex}
+                  onSelect={setIndex}
+                />
+              </section>
+            )}
+          </>
+        ) : (
+          <FavoritesView favorites={favoriteBooks} onRemove={removeFavorite} />
         )}
       </main>
       <footer className="app-footer">
diff --git a/src/__snapshots__/App.test.tsx.snap b/src/__snapshots__/App.test.tsx.snap
index 9ac41dc..87f2fba 100644
--- a/src/__snapshots__/App.test.tsx.snap
+++ b/src/__snapshots__/App.test.tsx.snap
@@ -18,6 +18,23 @@ exports[`App > matches the snapshot 1`] = `
     <main
       class="app-main"
     >
+      <nav
+        aria-label="Library views"
+        class="view-navigation"
+      >
+        <button
+          aria-pressed="true"
+          type="button"
+        >
+          Library
+        </button>
+        <button
+          aria-pressed="false"
+          type="button"
+        >
+          Favorites
+        </button>
+      </nav>
       <div
         class="library-controls"
       >
@@ -212,19 +229,6 @@ exports[`App > matches the snapshot 1`] = `
           </select>
         </label>
       </section>
-      <section
-        aria-labelledby="favorites-heading"
-        class="favorites-view"
-      >
-        <h2
-          id="favorites-heading"
-        >
-          Favorites
-        </h2>
-        <p>
-          No favorite books yet.
-        </p>
-      </section>
     </main>
     <footer
       class="app-footer"
diff --git a/src/components/FavoritesView.test.tsx b/src/components/FavoritesView.test.tsx
index f61fd1f..fb8e7d6 100644
--- a/src/components/FavoritesView.test.tsx
+++ b/src/components/FavoritesView.test.tsx
@@ -1,25 +1,22 @@
 import { fireEvent, render, screen } from "@testing-library/react";
 import { describe, expect, it, vi } from "vitest";
-import type { Book } from "../types";
+import type { FavoriteBook } from "../types";
 import { FavoritesView } from "./FavoritesView";
 
-const books: Book[] = [
+const favorites: FavoriteBook[] = [
   {
     key: "/works/OL1",
     title: "The Hobbit",
     authors: ["J. R. R. Tolkien"],
     firstPublishYear: 1937,
-    averageRating: 4.2,
-    ratingsCount: 100,
     coverId: 123,
-    subjects: ["fantasy"],
   },
 ];
 
 describe("FavoritesView", () => {
   it("shows a favorite with its author and remove control", () => {
     const onRemove = vi.fn();
-    render(<FavoritesView books={books} favoriteKeys={["/works/OL1"]} onRemove={onRemove} />);
+    render(<FavoritesView favorites={favorites} onRemove={onRemove} />);
 
     expect(screen.getByRole("heading", { name: "The Hobbit" })).toBeInTheDocument();
     expect(screen.getByText("J. R. R. Tolkien")).toBeInTheDocument();
@@ -30,15 +27,32 @@ describe("FavoritesView", () => {
   });
 
   it("shows an empty state", () => {
-    render(<FavoritesView books={books} favoriteKeys={[]} onRemove={vi.fn()} />);
+    render(<FavoritesView favorites={[]} onRemove={vi.fn()} />);
 
     expect(screen.getByText("No favorite books yet.")).toBeInTheDocument();
   });
 
+  it("orders favorites alphabetically in the overview", () => {
+    const favoritesOutOfOrder: FavoriteBook[] = [
+      favorites[0],
+      {
+        key: "/works/OL2",
+        title: "A Wizard of Earthsea",
+        authors: ["Ursula K. Le Guin"],
+        firstPublishYear: 1968,
+        coverId: null,
+      },
+    ];
+
+    render(<FavoritesView favorites={favoritesOutOfOrder} onRemove={vi.fn()} />);
+
+    expect(
+      screen.getAllByRole("heading", { level: 3 }).map((heading) => heading.textContent),
+    ).toEqual(["A Wizard of Earthsea", "The Hobbit"]);
+  });
+
   it("matches the rendered snapshot", () => {
-    const { container } = render(
-      <FavoritesView books={books} favoriteKeys={["/works/OL1"]} onRemove={vi.fn()} />,
-    );
+    const { container } = render(<FavoritesView favorites={favorites} onRemove={vi.fn()} />);
 
     expect(container).toMatchSnapshot();
   });
diff --git a/src/components/FavoritesView.tsx b/src/components/FavoritesView.tsx
index 64e4e5f..5d4f6b7 100644
--- a/src/components/FavoritesView.tsx
+++ b/src/components/FavoritesView.tsx
@@ -1,31 +1,36 @@
-import type { Book } from "../types";
+import type { FavoriteBook } from "../types";
 import "./FavoritesView.css";
 
 interface FavoritesViewProps {
-  books: Book[];
-  favoriteKeys: string[];
+  favorites: FavoriteBook[];
   onRemove: (bookKey: string) => void;
 }
 
-export function FavoritesView({ books, favoriteKeys, onRemove }: FavoritesViewProps) {
-  const favorites = books.filter((book) => favoriteKeys.includes(book.key));
+export function FavoritesView({ favorites, onRemove }: FavoritesViewProps) {
+  const sortedFavorites = [...favorites].sort((left, right) =>
+    (left.title ?? "Saved book").localeCompare(right.title ?? "Saved book"),
+  );
 
   return (
     <section className="favorites-view" aria-labelledby="favorites-heading">
       <h2 id="favorites-heading">Favorites</h2>
-      {favorites.length === 0 ? (
+      {sortedFavorites.length === 0 ? (
         <p>No favorite books yet.</p>
       ) : (
         <ul>
-          {favorites.map((book) => (
+          {sortedFavorites.map((book) => (
             <li key={book.key}>
               <div>
-                <h3>{book.title}</h3>
-                <p>{book.authors.length > 0 ? book.authors.join(", ") : "Unknown author"}</p>
+                <h3>{book.title ?? "Saved book"}</h3>
+                <p>
+                  {book.authors.length > 0
+                    ? book.authors.join(", ")
+                    : "Book details will appear when available."}
+                </p>
               </div>
               <button
                 type="button"
-                aria-label={`Remove ${book.title} from favorites list`}
+                aria-label={`Remove ${book.title ?? "saved book"} from favorites list`}
                 onClick={() => onRemove(book.key)}
               >
                 Remove
diff --git a/src/hooks/useFavorites.test.ts b/src/hooks/useFavorites.test.ts
index ad509cf..52b178e 100644
--- a/src/hooks/useFavorites.test.ts
+++ b/src/hooks/useFavorites.test.ts
@@ -1,28 +1,53 @@
-import { act } from "@testing-library/react";
+import { act, renderHook } from "@testing-library/react";
 import { beforeEach, describe, expect, it } from "vitest";
-import { renderHook } from "@testing-library/react";
+import type { Book } from "../types";
 import { useFavorites } from "./useFavorites";
 
+const book: Book = {
+  key: "/works/OL1",
+  title: "The Hobbit",
+  authors: ["J. R. R. Tolkien"],
+  firstPublishYear: 1937,
+  averageRating: 4.2,
+  ratingsCount: 100,
+  coverId: 123,
+  subjects: ["fantasy"],
+};
+
 describe("useFavorites", () => {
   beforeEach(() => {
     localStorage.clear();
   });
 
-  it("stores toggled book keys in local storage", () => {
+  it("stores the book details needed by the favorites overview", () => {
     const { result } = renderHook(() => useFavorites());
 
-    act(() => result.current.toggleFavorite("/works/OL1"));
-
-    expect(result.current.favoriteKeys).toEqual(["/works/OL1"]);
-    expect(localStorage.getItem("t19.favorites")).toBe(JSON.stringify(["/works/OL1"]));
+    act(() => result.current.toggleFavorite(book));
+
+    expect(result.current.isFavorite(book.key)).toBe(true);
+    expect(result.current.favoriteBooks).toEqual([
+      {
+        key: book.key,
+        title: book.title,
+        authors: book.authors,
+        firstPublishYear: book.firstPublishYear,
+        coverId: book.coverId,
+      },
+    ]);
   });
 
-  it("restores saved favorites", () => {
-    localStorage.setItem("t19.favorites", JSON.stringify(["/works/OL1"]));
+  it("keeps a legacy favorite key and fills in its details when the book is available", () => {
+    localStorage.setItem("t19.favorites", JSON.stringify([book.key]));
 
     const { result } = renderHook(() => useFavorites());
 
-    expect(result.current.favoriteKeys).toEqual(["/works/OL1"]);
+    expect(result.current.isFavorite(book.key)).toBe(true);
+    act(() => result.current.updateFavoriteDetails(book));
+
+    expect(result.current.favoriteBooks[0]).toMatchObject({
+      key: book.key,
+      title: book.title,
+    });
   });
 
   it("uses no favorites when stored data is corrupt", () => {
@@ -30,6 +55,6 @@ describe("useFavorites", () => {
 
     const { result } = renderHook(() => useFavorites());
 
-    expect(result.current.favoriteKeys).toEqual([]);
+    expect(result.current.favoriteBooks).toEqual([]);
   });
 });
diff --git a/src/hooks/useFavorites.ts b/src/hooks/useFavorites.ts
index 7a0d9bf..2d0332e 100644
--- a/src/hooks/useFavorites.ts
+++ b/src/hooks/useFavorites.ts
@@ -1,53 +1,136 @@
-import { useState } from "react";
+import { useCallback, useState } from "react";
+import type { Book, FavoriteBook } from "../types";
 
 const FAVORITES_KEY = "t19.favorites";
 
-function readFavorites(): string[] {
+function readFavorites(): FavoriteBook[] {
   try {
-    const storedFavorites = localStorage.getItem(FAVORITES_KEY);
-    if (storedFavorites === null) {
+    const storedValue = localStorage.getItem(FAVORITES_KEY);
+    if (storedValue === null) {
       return [];
     }
 
-    const favorites: unknown = JSON.parse(storedFavorites);
-    if (!Array.isArray(favorites) || favorites.some((favorite) => typeof favorite !== "string")) {
+    const parsedFavorites: unknown = JSON.parse(storedValue);
+    if (!Array.isArray(parsedFavorites)) {
       return [];
     }
 
-    return [...new Set(favorites)];
+    return uniqueFavorites(
+      parsedFavorites.flatMap((favorite) => {
+        if (typeof favorite === "string" && favorite.length > 0) {
+          return [legacyFavorite(favorite)];
+        }
+        return isFavoriteBook(favorite) ? [favorite] : [];
+      }),
+    );
   } catch {
     return [];
   }
 }
 
-function saveFavorites(favoriteKeys: string[]) {
+function saveFavorites(favorites: FavoriteBook[]) {
   try {
-    localStorage.setItem(FAVORITES_KEY, JSON.stringify(favoriteKeys));
+    localStorage.setItem(FAVORITES_KEY, JSON.stringify(favorites));
   } catch {
     return;
   }
 }
 
 export function useFavorites() {
-  const [favoriteKeys, setFavoriteKeys] = useState(readFavorites);
-
-  function toggleFavorite(bookKey: string) {
-    setFavoriteKeys((currentKeys) => {
-      const nextKeys = currentKeys.includes(bookKey)
-        ? currentKeys.filter((key) => key !== bookKey)
-        : [...currentKeys, bookKey];
-      saveFavorites(nextKeys);
-      return nextKeys;
+  const [favoriteBooks, setFavoriteBooks] = useState(readFavorites);
+
+  const isFavorite = useCallback(
+    (bookKey: string) => favoriteBooks.some((book) => book.key === bookKey),
+    [favoriteBooks],
+  );
+
+  function toggleFavorite(book: Book) {
+    setFavoriteBooks((currentFavorites) => {
+      const isSaved = currentFavorites.some((favorite) => favorite.key === book.key);
+      const nextFavorites = isSaved
+        ? currentFavorites.filter((favorite) => favorite.key !== book.key)
+        : [...currentFavorites, toFavoriteBook(book)];
+      saveFavorites(nextFavorites);
+      return nextFavorites;
     });
   }
 
   function removeFavorite(bookKey: string) {
-    setFavoriteKeys((currentKeys) => {
-      const nextKeys = currentKeys.filter((key) => key !== bookKey);
-      saveFavorites(nextKeys);
-      return nextKeys;
+    setFavoriteBooks((currentFavorites) => {
+      const nextFavorites = currentFavorites.filter((favorite) => favorite.key !== bookKey);
+      saveFavorites(nextFavorites);
+      return nextFavorites;
     });
   }
 
-  return { favoriteKeys, toggleFavorite, removeFavorite };
+  const updateFavoriteDetails = useCallback((book: Book) => {
+    setFavoriteBooks((currentFavorites) => {
+      const matchingFavorite = currentFavorites.find((favorite) => favorite.key === book.key);
+      if (matchingFavorite === undefined || favoriteMatchesBook(matchingFavorite, book)) {
+        return currentFavorites;
+      }
+
+      const nextFavorites = currentFavorites.map((favorite) =>
+        favorite.key === book.key ? toFavoriteBook(book) : favorite,
+      );
+      saveFavorites(nextFavorites);
+      return nextFavorites;
+    });
+  }, []);
+
+  return { favoriteBooks, isFavorite, toggleFavorite, removeFavorite, updateFavoriteDetails };
+}
+
+function isFavoriteBook(value: unknown): value is FavoriteBook {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+
+  const favorite = value as Record<string, unknown>;
+  return (
+    typeof favorite.key === "string" &&
+    favorite.key.length > 0 &&
+    (typeof favorite.title === "string" || favorite.title === null) &&
+    Array.isArray(favorite.authors) &&
+    favorite.authors.every((author) => typeof author === "string") &&
+    (typeof favorite.firstPublishYear === "number" || favorite.firstPublishYear === null) &&
+    (typeof favorite.coverId === "number" || favorite.coverId === null)
+  );
+}
+
+function uniqueFavorites(favorites: FavoriteBook[]): FavoriteBook[] {
+  const favoritesByKey = new Map<string, FavoriteBook>();
+
+  for (const favorite of favorites) {
+    const existingFavorite = favoritesByKey.get(favorite.key);
+    if (existingFavorite === undefined || existingFavorite.title === null) {
+      favoritesByKey.set(favorite.key, favorite);
+    }
+  }
+
+  return [...favoritesByKey.values()];
+}
+
+function legacyFavorite(key: string): FavoriteBook {
+  return { key, title: null, authors: [], firstPublishYear: null, coverId: null };
+}
+
+function toFavoriteBook(book: Book): FavoriteBook {
+  return {
+    key: book.key,
+    title: book.title,
+    authors: book.authors,
+    firstPublishYear: book.firstPublishYear,
+    coverId: book.coverId,
+  };
+}
+
+function favoriteMatchesBook(favorite: FavoriteBook, book: Book): boolean {
+  return (
+    favorite.title === book.title &&
+    favorite.authors.length === book.authors.length &&
+    favorite.authors.every((author, index) => author === book.authors[index]) &&
+    favorite.firstPublishYear === book.firstPublishYear &&
+    favorite.coverId === book.coverId
+  );
 }
diff --git a/src/types.ts b/src/types.ts
index eaefb68..194accb 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -9,6 +9,14 @@ export interface Book {
   subjects: string[];
 }
 
+export interface FavoriteBook {
+  key: string;
+  title: string | null;
+  authors: string[];
+  firstPublishYear: number | null;
+  coverId: number | null;
+}
+
 export interface OpenLibrarySearchDoc {
   key: string;
   title: string;