From e34d983a6824133992b979fa9ea3e1389c16f51f Mon Sep 17 00:00:00 2001
From: Daniel Tombor <t.dani12@gmail.com>
Date: Fri, 10 Jul 2026 12:39:33 +0100
Subject: [PATCH] =?UTF-8?q?feat:=20Feed=20core=20=E2=80=94=20env-provision?=
 =?UTF-8?q?ed,=20input-driven=20paging/search=20engine?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The foundational layer for offline-first paged feeds. One call — .feed(.posts) —
owns a FeedModel, wires its fetch pipeline from the environment, and scopes the
model + FeedState + control actions for the subtree; children read the model
back with @Feed(PostsQuery.self).

- PageableQuery: the domain query itself drives the feed (isSearch/cursor/
  page(after:)); conformances for Posts/Quotes/CatalogueSearch queries and an
  input-less CatalogueSyncQuery for the SyncGroup-backed catalogue refresh
- FeedModel: fetch(input) is the one entry point — the input decides browse vs
  search vs continuation; page-1 supersedes in-flight requests and superseded
  callers converge on the winner's receipt (race-proof); continuations fail
  quietly; returns FeedPage receipts so the owning view keeps paging state
- FeedConfiguration: label + composed fetch pipeline (loader → upsert →
  nextCursor), with real pipelines as statics and stub injection for previews
- Self-contained components: FeedStatusLine, FeedLoadMoreCell, FeedEmptyView
  read \.feedState + \.loadFeed/\.retryFeed — nothing passed through inits
- tmbr-core: query DTOs gain Hashable, page(after:), languages/sources params,
  and view-facing convenience inits; closure-based RequestLoader in app-api
- Groundwork: CatalogueItemSyncDescriptor rename + .book descriptor fix,
  CatalogueSearchEngine, detail-section pre-work, test-target dependency and
  container-lifetime fixes

Tabs are intentionally untouched — they migrate in the stacked follow-ups
(blog → quotes → catalogue).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../Sources/AppApi/HTTP/RequestLoader.swift   |  11 +-
 app-api/Sources/AppApi/Sync/SyncLoaders.swift |  14 +-
 .../Sources/AppApi/Sync/SyncRequests.swift    |  14 +-
 app-core/Package.swift                        |   7 +-
 app-core/Sources/AppCore/Blog/BlogModel.swift |   6 +-
 .../Catalogue/CatalogueItemDetailView.swift   |  12 +-
 .../AppCore/Catalogue/CatalogueTab.swift      |   4 +-
 .../Catalogue/Detail/AlbumDetailSection.swift |  39 +-
 .../Catalogue/Detail/BookDetailSection.swift  |  43 +-
 .../Detail/CataloguePreviewHeader.swift       |  36 ++
 .../Catalogue/Detail/MovieDetailSection.swift |  36 +-
 .../Detail/OrphanDetailSection.swift          |  29 +-
 .../Detail/PlaylistDetailSection.swift        |  32 +-
 .../Detail/PodcastDetailSection.swift         |  39 +-
 .../Catalogue/Detail/SongDetailSection.swift  |  39 +-
 .../Search/CatalogueSearchEngine.swift        |  55 +++
 .../Catalogue/Sync/CatalogueItemSync.swift    |  54 ---
 .../Sync/CatalogueItemSyncDescriptor.swift    |  65 +++
 .../AppCore/Catalogue/Sync/Loader.swift       |  11 +-
 .../AppCore/Catalogue/Sync/Upserter.swift     |  29 +-
 .../Views/CatalogueItemStatusLine.swift       |   4 +-
 app-core/Sources/AppCore/Feed/Feed.swift      |  31 ++
 .../AppCore/Feed/FeedConfiguration.swift      | 198 ++++++++
 .../Sources/AppCore/Feed/FeedEmptyView.swift  |  38 ++
 .../AppCore/Feed/FeedEnvironment.swift        |  31 ++
 .../AppCore/Feed/FeedLoadMoreCell.swift       |  35 ++
 app-core/Sources/AppCore/Feed/FeedModel.swift | 228 +++++++++
 .../AppCore/Feed/FeedPageLoadAction.swift     |  15 +
 .../AppCore/Feed/FeedRetryAction.swift        |  16 +
 app-core/Sources/AppCore/Feed/FeedState.swift |  44 ++
 .../Sources/AppCore/Feed/FeedStatusLine.swift |  41 ++
 .../Sources/AppCore/Feed/FilterMapping.swift  |  34 ++
 .../Sources/AppCore/Feed/PageableQuery.swift  |  43 ++
 .../AppCore/Feed/SyncGroup+Catalogue.swift    |  74 +++
 .../Preferences/View+Preferences.swift        |   4 +-
 .../Sources/AppCore/Shared/LoadError.swift    |   2 +-
 app-core/Sources/AppCore/Shared/Log.swift     |   1 +
 .../CatalogueItemSyncSeamTests.swift          |  17 +-
 .../CoreAppTests/CatalogueUpsertTests.swift   |   1 +
 .../Tests/CoreAppTests/FeedModelTests.swift   | 431 ++++++++++++++++++
 .../Tests/CoreAppTests/FeedSeamTests.swift    | 118 +++++
 .../Tests/CoreAppTests/PostUpsertTests.swift  |  23 +-
 .../AppPersistence/CatalogueCategory.swift    |   4 +
 tmbr-app/Personal/PersonalApp.swift           |   3 +-
 tmbr-app/Reader/CatalogueSync.swift           |  24 -
 tmbr-app/Reader/ReaderApp.swift               |  33 +-
 tmbr-app/Reader/ReaderPosts.swift             |  69 ---
 tmbr-app/tmbr-app.xcodeproj/project.pbxproj   |  32 +-
 tmbr-app/tmbr/RootView.swift                  |   3 +-
 .../TmbrCore/Pagination/PostsQuery.swift      |  54 ++-
 .../TmbrCore/Pagination/QuotesQuery.swift     |  52 ++-
 .../Search/CatalogueSearchQuery.swift         |   7 +-
 52 files changed, 1885 insertions(+), 400 deletions(-)
 create mode 100644 app-core/Sources/AppCore/Catalogue/Detail/CataloguePreviewHeader.swift
 create mode 100644 app-core/Sources/AppCore/Catalogue/Search/CatalogueSearchEngine.swift
 delete mode 100644 app-core/Sources/AppCore/Catalogue/Sync/CatalogueItemSync.swift
 create mode 100644 app-core/Sources/AppCore/Catalogue/Sync/CatalogueItemSyncDescriptor.swift
 create mode 100644 app-core/Sources/AppCore/Feed/Feed.swift
 create mode 100644 app-core/Sources/AppCore/Feed/FeedConfiguration.swift
 create mode 100644 app-core/Sources/AppCore/Feed/FeedEmptyView.swift
 create mode 100644 app-core/Sources/AppCore/Feed/FeedEnvironment.swift
 create mode 100644 app-core/Sources/AppCore/Feed/FeedLoadMoreCell.swift
 create mode 100644 app-core/Sources/AppCore/Feed/FeedModel.swift
 create mode 100644 app-core/Sources/AppCore/Feed/FeedPageLoadAction.swift
 create mode 100644 app-core/Sources/AppCore/Feed/FeedRetryAction.swift
 create mode 100644 app-core/Sources/AppCore/Feed/FeedState.swift
 create mode 100644 app-core/Sources/AppCore/Feed/FeedStatusLine.swift
 create mode 100644 app-core/Sources/AppCore/Feed/FilterMapping.swift
 create mode 100644 app-core/Sources/AppCore/Feed/PageableQuery.swift
 create mode 100644 app-core/Sources/AppCore/Feed/SyncGroup+Catalogue.swift
 create mode 100644 app-core/Tests/CoreAppTests/FeedModelTests.swift
 create mode 100644 app-core/Tests/CoreAppTests/FeedSeamTests.swift
 delete mode 100644 tmbr-app/Reader/CatalogueSync.swift
 delete mode 100644 tmbr-app/Reader/ReaderPosts.swift

diff --git a/app-api/Sources/AppApi/HTTP/RequestLoader.swift b/app-api/Sources/AppApi/HTTP/RequestLoader.swift
index 031d2ef5..c9632769 100644
--- a/app-api/Sources/AppApi/HTTP/RequestLoader.swift
+++ b/app-api/Sources/AppApi/HTTP/RequestLoader.swift
@@ -31,14 +31,21 @@ public extension RequestLoader where Input == Void {
 public extension RequestLoader {
 
     /// Loads `request` without authentication.
-    init<R: Request>(request: R, session: URLSession = .shared) where R.Input == Input, R.Response == Response {
+    init<R: Request>(
+        request: R,
+        session: URLSession = .shared
+    ) where R.Input == Input, R.Response == Response {
         self.init { input in
             try await Self.send(request, input, token: nil, session: session)
         }
     }
 
     /// Loads `request` with a bearer token from `auth`, refreshing once on a 401 and retrying.
-    init<R: Request>(request: R, session: URLSession = .shared, auth: AuthProvider) where R.Input == Input, R.Response == Response {
+    init<R: Request>(
+        request: R,
+        session: URLSession = .shared,
+        auth: AuthProvider
+    ) where R.Input == Input, R.Response == Response {
         self.init { input in
             let token = await auth.value
             do {
diff --git a/app-api/Sources/AppApi/Sync/SyncLoaders.swift b/app-api/Sources/AppApi/Sync/SyncLoaders.swift
index c51f07d1..546ffd20 100644
--- a/app-api/Sources/AppApi/Sync/SyncLoaders.swift
+++ b/app-api/Sources/AppApi/Sync/SyncLoaders.swift
@@ -10,7 +10,7 @@ public typealias BooksLoader     = RequestLoader<PageQuery, PageResult<BookRespo
 public typealias MoviesLoader    = RequestLoader<PageQuery, PageResult<MovieResponse>>
 public typealias PodcastsLoader  = RequestLoader<PageQuery, PageResult<PodcastResponse>>
 public typealias PlaylistsLoader = RequestLoader<PageQuery, PageResult<PlaylistResponse>>
-public typealias PostsLoader     = RequestLoader<PageQuery, PageResult<PostResponse>>
+public typealias PostsLoader     = RequestLoader<PostsQuery, PageResult<PostResponse>>
 public typealias OrphansLoader    = RequestLoader<OrphanPageQuery, PageResult<PreviewResponse>>
 public typealias CategoriesLoader = RequestLoader<Void, [CategoryResponse]>
 public typealias DeletionsLoader  = RequestLoader<SinceQuery, [DeletionRecord]>
@@ -138,15 +138,15 @@ public extension DeletionsLoader {
 
 // MARK: - Search loaders (unauthenticated — Reader app)
 //
-// One-shot loaders: call `.load(from: query)` with the search query, get results back.
-// No pagination — search endpoints return an unpaginated array.
+// Catalogue uses a dedicated search endpoint. Quotes reuses its paginated list endpoint with
+// an optional `term` field — same pattern as PostsLoader.
 
-public typealias PostSearchLoader      = RequestLoader<PostSearchQuery, PageResult<PostResponse>>
+public typealias QuotesLoader          = RequestLoader<QuotesQuery, PageResult<QuoteResponse>>
 public typealias CatalogueSearchLoader = RequestLoader<CatalogueSearchQuery, CatalogueSearchResponse>
 
-public extension PostSearchLoader {
-    static func searchPosts(baseURL: URL, session: URLSession = .shared) -> Self {
-        PostSearchLoader(request: PostSearchRequest.postSearch(baseURL: baseURL), session: session)
+public extension QuotesLoader {
+    static func quotes(baseURL: URL, session: URLSession = .shared) -> Self {
+        QuotesLoader(request: QuotesRequest.quotes(baseURL: baseURL), session: session)
     }
 }
 
diff --git a/app-api/Sources/AppApi/Sync/SyncRequests.swift b/app-api/Sources/AppApi/Sync/SyncRequests.swift
index 761e035b..18da3188 100644
--- a/app-api/Sources/AppApi/Sync/SyncRequests.swift
+++ b/app-api/Sources/AppApi/Sync/SyncRequests.swift
@@ -37,7 +37,7 @@ public extension Request where Self == PlaylistsRequest {
     static func playlistQuery(baseURL: URL) -> Self { .query(baseURL: baseURL, path: "api/playlists") }
 }
 
-public typealias PostsRequest = BasicRequest<PageQuery, PageResult<PostResponse>>
+public typealias PostsRequest = BasicRequest<PostsQuery, PageResult<PostResponse>>
 public extension Request where Self == PostsRequest {
     static func postQuery(baseURL: URL) -> Self { .query(baseURL: baseURL, path: "api/posts") }
 }
@@ -62,13 +62,13 @@ public extension Request where Self == DeletionsRequest {
 
 // MARK: - Search requests
 //
-// Unpaginated one-shot requests — send the search query, get a complete result array back.
-// Each uses `.query(baseURL:path:)` so the `Input` struct is URL-encoded into query parameters
-// via `QueryItemEncoder`.
+// Catalogue search uses a dedicated endpoint; quotes and blog reuse their paginated list endpoints
+// with an optional `term` field. Each uses `.query(baseURL:path:)` so the Input struct is
+// URL-encoded into query parameters via `QueryItemEncoder`.
 
-public typealias PostSearchRequest = BasicRequest<PostSearchQuery, PageResult<PostResponse>>
-public extension Request where Self == PostSearchRequest {
-    static func postSearch(baseURL: URL) -> Self { .query(baseURL: baseURL, path: "api/posts") }
+public typealias QuotesRequest = BasicRequest<QuotesQuery, PageResult<QuoteResponse>>
+public extension Request where Self == QuotesRequest {
+    static func quotes(baseURL: URL) -> Self { .query(baseURL: baseURL, path: "api/quotes") }
 }
 
 public typealias CatalogueSearchRequest = BasicRequest<CatalogueSearchQuery, CatalogueSearchResponse>
diff --git a/app-core/Package.swift b/app-core/Package.swift
index fad6a804..3852ba45 100644
--- a/app-core/Package.swift
+++ b/app-core/Package.swift
@@ -27,7 +27,12 @@ let package = Package(
         ),
         .testTarget(
             name: "AppCoreTests",
-            dependencies: ["AppCore"]
+            dependencies: [
+                "AppCore",
+                .product(name: "TmbrCore", package: "tmbr-core"),
+                .product(name: "AppApi", package: "app-api"),
+                .product(name: "AppPersistence", package: "app-persistence"),
+            ]
         ),
     ]
 )
diff --git a/app-core/Sources/AppCore/Blog/BlogModel.swift b/app-core/Sources/AppCore/Blog/BlogModel.swift
index 4d73203b..4c9c6eb7 100644
--- a/app-core/Sources/AppCore/Blog/BlogModel.swift
+++ b/app-core/Sources/AppCore/Blog/BlogModel.swift
@@ -1,11 +1,7 @@
 import Foundation
 import OSLog
 
-/// Which load operation is currently in flight, if any.
-public enum LoadingState: Equatable, Sendable {
-    case refresh
-    case page
-}
+// `LoadingState` now lives with `FeedState` (Feed/FeedState.swift); this model reuses it.
 
 /// Headless model for the Blog tab. Tracks refresh activity and outcome; the list itself comes
 /// from `@Query` in the view.
diff --git a/app-core/Sources/AppCore/Catalogue/CatalogueItemDetailView.swift b/app-core/Sources/AppCore/Catalogue/CatalogueItemDetailView.swift
index 1e313f2d..188c0378 100644
--- a/app-core/Sources/AppCore/Catalogue/CatalogueItemDetailView.swift
+++ b/app-core/Sources/AppCore/Catalogue/CatalogueItemDetailView.swift
@@ -55,17 +55,17 @@ struct CatalogueItemDetailView: View {
     private var typeSection: some View {
         switch item.category {
         case .song:
-            SongDetailSection(previewID: item.id)
+            SongDetailSection(item: item)
         case .album:
-            AlbumDetailSection(previewID: item.id)
+            AlbumDetailSection(item: item)
         case .playlist:
-            PlaylistDetailSection(previewID: item.id)
+            PlaylistDetailSection(item: item)
         case .book:
-            BookDetailSection(previewID: item.id)
+            BookDetailSection(item: item)
         case .podcast:
-            PodcastDetailSection(previewID: item.id)
+            PodcastDetailSection(item: item)
         case .movie:
-            MovieDetailSection(previewID: item.id)
+            MovieDetailSection(item: item)
         case nil:
             OrphanDetailSection(item: item)
         }
diff --git a/app-core/Sources/AppCore/Catalogue/CatalogueTab.swift b/app-core/Sources/AppCore/Catalogue/CatalogueTab.swift
index 6be5e002..89c6d7ba 100644
--- a/app-core/Sources/AppCore/Catalogue/CatalogueTab.swift
+++ b/app-core/Sources/AppCore/Catalogue/CatalogueTab.swift
@@ -104,8 +104,8 @@ private struct CatalogueItemsList: View {
                 } label: {
                     VStack(alignment: .leading, spacing: 2) {
                         Text(item.primaryInfo)
-                        if let subtitle = item.secondaryInfo {
-                            Text(subtitle)
+                        if !item.secondaryInfo.isEmpty {
+                            Text(item.secondaryInfo)
                                 .font(.subheadline)
                                 .foregroundStyle(.secondary)
                         }
diff --git a/app-core/Sources/AppCore/Catalogue/Detail/AlbumDetailSection.swift b/app-core/Sources/AppCore/Catalogue/Detail/AlbumDetailSection.swift
index cd9216d4..8803deb2 100644
--- a/app-core/Sources/AppCore/Catalogue/Detail/AlbumDetailSection.swift
+++ b/app-core/Sources/AppCore/Catalogue/Detail/AlbumDetailSection.swift
@@ -20,35 +20,44 @@ private struct AlbumInfoLine: View {
 
 struct AlbumDetailSection: View {
 
-    let previewID: UUID
+    let item: PreviewRecord
 
-    @Query private var records: [AlbumRecord]
+    @Query
+    private var records: [AlbumRecord]
 
-    @Upserter(\.album) private var syncer
+    @Upserter(.album)
+    private var syncer
 
-    init(previewID: UUID) {
-        self.previewID = previewID
+    init(item: PreviewRecord) {
+        self.item = item
+        let previewID = item.id
         _records = Query(filter: #Predicate<AlbumRecord> { $0.previewID == previewID })
     }
 
     var body: some View {
-        if let album = records.first {
+        let album = records.first
+        let artist = album?.artist ?? item.secondaryInfo
+        Group {
             Section {
                 CatalogueItemHeader(
-                    title: album.title,
-                    artworkURL: album.artworkURL,
-                    credit: album.artist.isEmpty ? nil : "by \(album.artist)",
-                    info: { AlbumInfoLine(album: album) },
-                    resourceURLs: album.resourceURLs
+                    title: album?.title ?? item.primaryInfo,
+                    artworkURL: album?.artworkURL ?? item.imageURL,
+                    credit: artist.isEmpty ? nil : "by \(artist)",
+                    info: { if let album { AlbumInfoLine(album: album) } },
+                    resourceURLs: album?.resourceURLs ?? item.externalLinks
                 )
             }
-            .catalogueItemRefresh(id: previewID) { [sourceID = album.sourceID] in
-                if let sourceID { try await syncer(sourceID) }
-            }
-            if let sourceID = album.sourceID {
+            if let sourceID = item.sourceID {
                 TrackListSection(containerType: "album", containerSourceID: sourceID)
             }
         }
+        .catalogueItemRefresh(id: item.id) { [sourceID = item.sourceID] in
+            if let sourceID { try await syncer(sourceID) }
+        }
+        .task(id: item.id) {
+            guard records.isEmpty, let sourceID = item.sourceID else { return }
+            try? await syncer(sourceID)
+        }
     }
 
 }
diff --git a/app-core/Sources/AppCore/Catalogue/Detail/BookDetailSection.swift b/app-core/Sources/AppCore/Catalogue/Detail/BookDetailSection.swift
index b267d2cb..9d828429 100644
--- a/app-core/Sources/AppCore/Catalogue/Detail/BookDetailSection.swift
+++ b/app-core/Sources/AppCore/Catalogue/Detail/BookDetailSection.swift
@@ -20,31 +20,38 @@ private struct BookInfoLine: View {
 
 struct BookDetailSection: View {
 
-    let previewID: UUID
+    let item: PreviewRecord
 
-    @Query private var records: [BookRecord]
+    @Query
+    private var records: [BookRecord]
 
-    @Upserter(\.book) private var syncer
+    @Upserter(.book)
+    private var syncer
 
-    init(previewID: UUID) {
-        self.previewID = previewID
+    init(item: PreviewRecord) {
+        self.item = item
+        let previewID = item.id
         _records = Query(filter: #Predicate<BookRecord> { $0.previewID == previewID })
     }
 
     var body: some View {
-        if let book = records.first {
-            Section {
-                CatalogueItemHeader(
-                    title: book.title,
-                    artworkURL: book.coverURL,
-                    credit: book.author.isEmpty ? nil : "by \(book.author)",
-                    info: { BookInfoLine(book: book) },
-                    resourceURLs: book.resourceURLs
-                )
-            }
-            .catalogueItemRefresh(id: previewID) { [sourceID = book.sourceID] in
-                if let sourceID { try await syncer(sourceID) }
-            }
+        let book = records.first
+        let author = book?.author ?? item.secondaryInfo
+        Section {
+            CatalogueItemHeader(
+                title: book?.title ?? item.primaryInfo,
+                artworkURL: book?.coverURL ?? item.imageURL,
+                credit: author.isEmpty ? nil : "by \(author)",
+                info: { if let book { BookInfoLine(book: book) } },
+                resourceURLs: book?.resourceURLs ?? item.externalLinks
+            )
+        }
+        .catalogueItemRefresh(id: item.id) { [sourceID = item.sourceID] in
+            if let sourceID { try await syncer(sourceID) }
+        }
+        .task(id: item.id) {
+            guard records.isEmpty, let sourceID = item.sourceID else { return }
+            try? await syncer(sourceID)
         }
     }
 
diff --git a/app-core/Sources/AppCore/Catalogue/Detail/CataloguePreviewHeader.swift b/app-core/Sources/AppCore/Catalogue/Detail/CataloguePreviewHeader.swift
new file mode 100644
index 00000000..b90eafe3
--- /dev/null
+++ b/app-core/Sources/AppCore/Catalogue/Detail/CataloguePreviewHeader.swift
@@ -0,0 +1,36 @@
+import SwiftUI
+import AppPersistence
+
+/// A preview-backed catalogue item header, rendered entirely from a `PreviewRecord`.
+/// Used as a placeholder by typed detail sections while their backing record is being
+/// fetched, and as the permanent header by `OrphanDetailSection`.
+struct CataloguePreviewHeader: View {
+
+    let item: PreviewRecord
+
+    var body: some View {
+        Section {
+            CatalogueItemHeader(
+                title: item.primaryInfo,
+                artworkURL: item.imageURL,
+                info: { PreviewInfoLine(item: item) },
+                resourceURLs: item.externalLinks
+            )
+        }
+    }
+}
+
+// MARK: - Info line
+
+struct PreviewInfoLine: View {
+
+    let item: PreviewRecord
+
+    var body: some View {
+        let text = [item.secondaryInfo, item.categoryType.capitalized]
+            .filter { !$0.isEmpty }.joined(separator: " · ")
+        if !text.isEmpty {
+            Text(text).foregroundStyle(.secondary)
+        }
+    }
+}
diff --git a/app-core/Sources/AppCore/Catalogue/Detail/MovieDetailSection.swift b/app-core/Sources/AppCore/Catalogue/Detail/MovieDetailSection.swift
index ef12eafb..96a51755 100644
--- a/app-core/Sources/AppCore/Catalogue/Detail/MovieDetailSection.swift
+++ b/app-core/Sources/AppCore/Catalogue/Detail/MovieDetailSection.swift
@@ -20,30 +20,34 @@ private struct MovieInfoLine: View {
 
 struct MovieDetailSection: View {
 
-    let previewID: UUID
+    let item: PreviewRecord
 
     @Query private var records: [MovieRecord]
 
-    @Upserter(\.movie) private var syncer
+    @Upserter(.movie) private var syncer
 
-    init(previewID: UUID) {
-        self.previewID = previewID
+    init(item: PreviewRecord) {
+        self.item = item
+        let previewID = item.id
         _records = Query(filter: #Predicate<MovieRecord> { $0.previewID == previewID })
     }
 
     var body: some View {
-        if let movie = records.first {
-            Section {
-                CatalogueItemHeader(
-                    title: movie.title,
-                    artworkURL: movie.coverURL,
-                    info: { MovieInfoLine(movie: movie) },
-                    resourceURLs: movie.resourceURLs
-                )
-            }
-            .catalogueItemRefresh(id: previewID) { [sourceID = movie.sourceID] in
-                if let sourceID { try await syncer(sourceID) }
-            }
+        let movie = records.first
+        Section {
+            CatalogueItemHeader(
+                title: movie?.title ?? item.primaryInfo,
+                artworkURL: movie?.coverURL ?? item.imageURL,
+                info: { if let movie { MovieInfoLine(movie: movie) } },
+                resourceURLs: movie?.resourceURLs ?? item.externalLinks
+            )
+        }
+        .catalogueItemRefresh(id: item.id) { [sourceID = item.sourceID] in
+            if let sourceID { try await syncer(sourceID) }
+        }
+        .task(id: item.id) {
+            guard records.isEmpty, let sourceID = item.sourceID else { return }
+            try? await syncer(sourceID)
         }
     }
 
diff --git a/app-core/Sources/AppCore/Catalogue/Detail/OrphanDetailSection.swift b/app-core/Sources/AppCore/Catalogue/Detail/OrphanDetailSection.swift
index c2802946..ecb17781 100644
--- a/app-core/Sources/AppCore/Catalogue/Detail/OrphanDetailSection.swift
+++ b/app-core/Sources/AppCore/Catalogue/Detail/OrphanDetailSection.swift
@@ -1,35 +1,16 @@
 import SwiftUI
 import AppPersistence
 
-private struct OrphanInfoLine: View {
-    let item: PreviewRecord
-
-    var body: some View {
-        let text = [item.secondaryInfo, item.categoryType.capitalized]
-            .compactMap { $0 }.filter { !$0.isEmpty }.joined(separator: " · ")
-        if !text.isEmpty {
-            Text(text).foregroundStyle(.secondary)
-        }
-    }
-}
-
 struct OrphanDetailSection: View {
 
     let item: PreviewRecord
 
-    @Upserter(\.orphan) private var syncer
+    @Upserter(.orphan) private var syncer
 
     var body: some View {
-        Section {
-            CatalogueItemHeader(
-                title: item.primaryInfo,
-                artworkURL: item.imageURL,
-                info: { OrphanInfoLine(item: item) },
-                resourceURLs: item.externalLinks
-            )
-        }
-        .catalogueItemRefresh(id: item.id) { [id = item.id] in
-            try await syncer(id)
-        }
+        CataloguePreviewHeader(item: item)
+            .catalogueItemRefresh(id: item.id) { [id = item.id] in
+                try await syncer(id)
+            }
     }
 }
diff --git a/app-core/Sources/AppCore/Catalogue/Detail/PlaylistDetailSection.swift b/app-core/Sources/AppCore/Catalogue/Detail/PlaylistDetailSection.swift
index 9e0f403c..c5f7a45d 100644
--- a/app-core/Sources/AppCore/Catalogue/Detail/PlaylistDetailSection.swift
+++ b/app-core/Sources/AppCore/Catalogue/Detail/PlaylistDetailSection.swift
@@ -14,33 +14,39 @@ private struct PlaylistInfoLine: View {
 
 struct PlaylistDetailSection: View {
 
-    let previewID: UUID
+    let item: PreviewRecord
 
     @Query private var records: [PlaylistRecord]
 
-    @Upserter(\.playlist) private var syncer
+    @Upserter(.playlist) private var syncer
 
-    init(previewID: UUID) {
-        self.previewID = previewID
+    init(item: PreviewRecord) {
+        self.item = item
+        let previewID = item.id
         _records = Query(filter: #Predicate<PlaylistRecord> { $0.previewID == previewID })
     }
 
     var body: some View {
-        if let playlist = records.first {
+        let playlist = records.first
+        Group {
             Section {
                 CatalogueItemHeader(
-                    title: playlist.title,
-                    artworkURL: playlist.artworkURL,
-                    info: { PlaylistInfoLine(playlist: playlist) },
-                    resourceURLs: playlist.resourceURLs
+                    title: playlist?.title ?? item.primaryInfo,
+                    artworkURL: playlist?.artworkURL ?? item.imageURL,
+                    info: { if let playlist { PlaylistInfoLine(playlist: playlist) } },
+                    resourceURLs: playlist?.resourceURLs ?? item.externalLinks
                 )
             }
-            .catalogueItemRefresh(id: previewID) { [sourceID = playlist.sourceID] in
-                if let sourceID { try await syncer(sourceID) }
-            }
-            if let sourceID = playlist.sourceID {
+            if let sourceID = item.sourceID {
                 TrackListSection(containerType: "playlist", containerSourceID: sourceID)
             }
         }
+        .catalogueItemRefresh(id: item.id) { [sourceID = item.sourceID] in
+            if let sourceID { try await syncer(sourceID) }
+        }
+        .task(id: item.id) {
+            guard records.isEmpty, let sourceID = item.sourceID else { return }
+            try? await syncer(sourceID)
+        }
     }
 }
diff --git a/app-core/Sources/AppCore/Catalogue/Detail/PodcastDetailSection.swift b/app-core/Sources/AppCore/Catalogue/Detail/PodcastDetailSection.swift
index 6d3bb6ed..39f49945 100644
--- a/app-core/Sources/AppCore/Catalogue/Detail/PodcastDetailSection.swift
+++ b/app-core/Sources/AppCore/Catalogue/Detail/PodcastDetailSection.swift
@@ -26,31 +26,36 @@ private struct PodcastInfoLine: View {
 
 struct PodcastDetailSection: View {
 
-    let previewID: UUID
+    let item: PreviewRecord
 
     @Query private var records: [PodcastRecord]
 
-    @Upserter(\.podcast) private var syncer
+    @Upserter(.podcast) private var syncer
 
-    init(previewID: UUID) {
-        self.previewID = previewID
+    init(item: PreviewRecord) {
+        self.item = item
+        let previewID = item.id
         _records = Query(filter: #Predicate<PodcastRecord> { $0.previewID == previewID })
     }
 
     var body: some View {
-        if let podcast = records.first {
-            Section {
-                CatalogueItemHeader(
-                    title: podcast.title,
-                    artworkURL: podcast.artworkURL,
-                    credit: podcast.episodeTitle.isEmpty ? nil : podcast.episodeTitle,
-                    info: { PodcastInfoLine(podcast: podcast) },
-                    resourceURLs: podcast.resourceURLs
-                )
-            }
-            .catalogueItemRefresh(id: previewID) { [sourceID = podcast.sourceID] in
-                if let sourceID { try await syncer(sourceID) }
-            }
+        let podcast = records.first
+        let episodeTitle = podcast?.episodeTitle ?? item.secondaryInfo
+        Section {
+            CatalogueItemHeader(
+                title: podcast?.title ?? item.primaryInfo,
+                artworkURL: podcast?.artworkURL ?? item.imageURL,
+                credit: episodeTitle.isEmpty ? nil : episodeTitle,
+                info: { if let podcast { PodcastInfoLine(podcast: podcast) } },
+                resourceURLs: podcast?.resourceURLs ?? item.externalLinks
+            )
+        }
+        .catalogueItemRefresh(id: item.id) { [sourceID = item.sourceID] in
+            if let sourceID { try await syncer(sourceID) }
+        }
+        .task(id: item.id) {
+            guard records.isEmpty, let sourceID = item.sourceID else { return }
+            try? await syncer(sourceID)
         }
     }
 
diff --git a/app-core/Sources/AppCore/Catalogue/Detail/SongDetailSection.swift b/app-core/Sources/AppCore/Catalogue/Detail/SongDetailSection.swift
index 8327e0a5..a7aec5d3 100644
--- a/app-core/Sources/AppCore/Catalogue/Detail/SongDetailSection.swift
+++ b/app-core/Sources/AppCore/Catalogue/Detail/SongDetailSection.swift
@@ -20,31 +20,36 @@ private struct SongInfoLine: View {
 
 struct SongDetailSection: View {
 
-    let previewID: UUID
+    let item: PreviewRecord
 
     @Query private var records: [SongRecord]
 
-    @Upserter(\.song) private var syncer
+    @Upserter(.song) private var syncer
 
-    init(previewID: UUID) {
-        self.previewID = previewID
+    init(item: PreviewRecord) {
+        self.item = item
+        let previewID = item.id
         _records = Query(filter: #Predicate<SongRecord> { $0.previewID == previewID })
     }
 
     var body: some View {
-        if let song = records.first {
-            Section {
-                CatalogueItemHeader(
-                    title: song.title,
-                    artworkURL: song.artworkURL,
-                    credit: song.artist.isEmpty ? nil : "by \(song.artist)",
-                    info: { SongInfoLine(song: song) },
-                    resourceURLs: song.resourceURLs
-                )
-            }
-            .catalogueItemRefresh(id: previewID) { [sourceID = song.sourceID] in
-                if let sourceID { try await syncer(sourceID) }
-            }
+        let song = records.first
+        let artist = song?.artist ?? item.secondaryInfo
+        Section {
+            CatalogueItemHeader(
+                title: song?.title ?? item.primaryInfo,
+                artworkURL: song?.artworkURL ?? item.imageURL,
+                credit: artist.isEmpty ? nil : "by \(artist)",
+                info: { if let song { SongInfoLine(song: song) } },
+                resourceURLs: song?.resourceURLs ?? item.externalLinks
+            )
+        }
+        .catalogueItemRefresh(id: item.id) { [sourceID = item.sourceID] in
+            if let sourceID { try await syncer(sourceID) }
+        }
+        .task(id: item.id) {
+            guard records.isEmpty, let sourceID = item.sourceID else { return }
+            try? await syncer(sourceID)
         }
     }
 
diff --git a/app-core/Sources/AppCore/Catalogue/Search/CatalogueSearchEngine.swift b/app-core/Sources/AppCore/Catalogue/Search/CatalogueSearchEngine.swift
new file mode 100644
index 00000000..4a233b0a
--- /dev/null
+++ b/app-core/Sources/AppCore/Catalogue/Search/CatalogueSearchEngine.swift
@@ -0,0 +1,55 @@
+import Foundation
+import SwiftData
+import AppPersistence
+import TmbrCore
+
+/// Observable engine that drives catalogue text search against the local SwiftData store.
+///
+/// The engine delegates the actual fetching and merging to `CatalogueStore.search(...)`, which runs
+/// two predicate-filtered `FetchDescriptor` queries — one over `PreviewRecord` (title/subtitle) and
+/// one over `NoteRecord` (body) — and resolves the cross-model note→preview join via a targeted
+/// predicate fetch of only the needed IDs.
+///
+/// This class exists because manual fetches don't trigger SwiftUI `@Query` reactivity — views observe
+/// `engine.results` via `@Observable` instead.
+///
+/// **Usage pattern** (from the view's `.task(id: searchText)`):
+/// 1. Call `search(term:in:categories:languages:)` immediately — renders cached results.
+/// 2. Await the network search action — it upserts newly-fetched results into the store.
+/// 3. Call `search(...)` again — picks up the upserted data.
+@MainActor
+@Observable
+public final class CatalogueSearchEngine {
+
+    /// The current search results, updated synchronously on each `search(...)` call.
+    public private(set) var results: [CatalogueSearchResult] = []
+
+    public init() {}
+
+    /// Runs the search via `CatalogueStore` and updates `results` synchronously.
+    /// Clears results when `term` is blank.
+    public func search(
+        term: String,
+        in context: ModelContext,
+        categories: Set<CatalogueCategory>,
+        languages: Set<Language>
+    ) {
+        guard !term.trimmingCharacters(in: .whitespaces).isEmpty else {
+            results = []
+            return
+        }
+        do {
+            results = try CatalogueStore(context: context).search(
+                term: term,
+                categories: categories,
+                languages: languages
+            )
+        } catch {
+            results = []
+        }
+    }
+
+    public func clear() {
+        results = []
+    }
+}
diff --git a/app-core/Sources/AppCore/Catalogue/Sync/CatalogueItemSync.swift b/app-core/Sources/AppCore/Catalogue/Sync/CatalogueItemSync.swift
deleted file mode 100644
index a9438692..00000000
--- a/app-core/Sources/AppCore/Catalogue/Sync/CatalogueItemSync.swift
+++ /dev/null
@@ -1,54 +0,0 @@
-import Foundation
-import AppPersistence
-import AppApi
-import TmbrCore
-
-/// Links the loader factory and store upsert function for one catalogue item type.
-///
-/// `@Loader(\.song)` reads `\.itemLoaders` directly (no recipe needed).
-/// `@Upserter(\.song)` keys into this recipe to find both `loaderPath` and `upserterPath`,
-/// ensuring the loader output type always matches the upserter input type at compile time.
-public struct CatalogueItemSync<ID: Sendable, Response: Decodable & Sendable>: Sendable {
-
-    public let label: String
-    public let loaderPath:   KeyPath<CatalogueItemLoaders,   @Sendable (URL, URLSession) -> RequestLoader<ID, Response>> & Sendable
-    public let upserterPath: KeyPath<CatalogueItemUpserters, @MainActor (CatalogueStore, Response) throws -> Void> & Sendable
-
-    public init(
-        _ label: String,
-        loaderPath:   KeyPath<CatalogueItemLoaders,   @Sendable (URL, URLSession) -> RequestLoader<ID, Response>> & Sendable,
-        upserterPath: KeyPath<CatalogueItemUpserters, @MainActor (CatalogueStore, Response) throws -> Void> & Sendable
-    ) {
-        self.label = label
-        self.loaderPath = loaderPath
-        self.upserterPath = upserterPath
-    }
-}
-
-// MARK: - Namespace
-
-/// Keypath-pair recipes linking each catalogue type's loader factory to its store upsert function.
-///
-/// `@Upserter` addresses into this namespace to compose the two seams. The network seam
-/// (`\.itemLoaders`) and persistence seam (`\.itemUpserters`) are each independently injectable
-/// via the environment; overriding one does not affect the other.
-public struct CatalogueItemSyncs: Sendable {
-
-    public let song:     CatalogueItemSync<Int,  SongResponse>
-    public let album:    CatalogueItemSync<Int,  AlbumResponse>
-    public let book:     CatalogueItemSync<Int,  BookResponse>
-    public let movie:    CatalogueItemSync<Int,  MovieResponse>
-    public let podcast:  CatalogueItemSync<Int,  PodcastResponse>
-    public let playlist: CatalogueItemSync<Int,  PlaylistResponse>
-    public let orphan:   CatalogueItemSync<UUID, PreviewResponse>
-
-    public init() {
-        song     = .init("song",     loaderPath: \.song,     upserterPath: \.song)
-        album    = .init("album",    loaderPath: \.album,    upserterPath: \.album)
-        book     = .init("book",     loaderPath: \.book,     upserterPath: \.book)
-        movie    = .init("movie",    loaderPath: \.movie,    upserterPath: \.movie)
-        podcast  = .init("podcast",  loaderPath: \.podcast,  upserterPath: \.podcast)
-        playlist = .init("playlist", loaderPath: \.playlist, upserterPath: \.playlist)
-        orphan   = .init("orphan",   loaderPath: \.orphan,   upserterPath: \.orphan)
-    }
-}
diff --git a/app-core/Sources/AppCore/Catalogue/Sync/CatalogueItemSyncDescriptor.swift b/app-core/Sources/AppCore/Catalogue/Sync/CatalogueItemSyncDescriptor.swift
new file mode 100644
index 00000000..5b8aeff0
--- /dev/null
+++ b/app-core/Sources/AppCore/Catalogue/Sync/CatalogueItemSyncDescriptor.swift
@@ -0,0 +1,65 @@
+import Foundation
+import AppPersistence
+import AppApi
+import TmbrCore
+
+/// Links the loader factory and store upsert function for one catalogue item type.
+///
+/// `@Loader(\.song)` reads `\.itemLoaders` directly (no recipe needed).
+/// `@Upserter(\.song)` keys into this recipe to find both `loaderPath` and `upserterPath`,
+/// ensuring the loader output type always matches the upserter input type at compile time.
+public struct CatalogueItemSyncDescriptor<ID: Sendable, Response: Decodable & Sendable>: Sendable {
+
+    public let label: String
+    
+    public let loaderPath:   KeyPath<CatalogueItemLoaders,   @Sendable (URL, URLSession) -> RequestLoader<ID, Response>> & Sendable
+    
+    public let upserterPath: KeyPath<CatalogueItemUpserters, @MainActor (CatalogueStore, Response) throws -> Void> & Sendable
+
+    public init(
+        _ label: String,
+        loaderPath:   KeyPath<CatalogueItemLoaders,   @Sendable (URL, URLSession) -> RequestLoader<ID, Response>> & Sendable,
+        upserterPath: KeyPath<CatalogueItemUpserters, @MainActor (CatalogueStore, Response) throws -> Void> & Sendable
+    ) {
+        self.label = label
+        self.loaderPath = loaderPath
+        self.upserterPath = upserterPath
+    }
+}
+
+// MARK: - Namespace
+
+extension CatalogueItemSyncDescriptor where ID == Int, Response == SongResponse {
+    
+    public static let song = Self("song", loaderPath: \.song, upserterPath: \.song)
+}
+    
+extension CatalogueItemSyncDescriptor where ID == Int, Response == AlbumResponse {
+    
+    public static let album = Self("album", loaderPath: \.album, upserterPath: \.album)
+}
+
+extension CatalogueItemSyncDescriptor where ID == Int, Response == BookResponse {
+
+    public static let book = Self("book", loaderPath: \.book, upserterPath: \.book)
+}
+    
+extension CatalogueItemSyncDescriptor where ID == Int, Response == MovieResponse {
+    
+    public static let movie = Self("movie", loaderPath: \.movie, upserterPath: \.movie)
+}
+   
+extension CatalogueItemSyncDescriptor where ID == Int, Response == PodcastResponse {
+    
+    public static let podcast = Self("podcast", loaderPath: \.podcast, upserterPath: \.podcast)
+}
+    
+extension CatalogueItemSyncDescriptor where ID == Int, Response == PlaylistResponse {
+    
+    public static let playlist = Self("playlist", loaderPath: \.playlist, upserterPath: \.playlist)
+}
+    
+extension CatalogueItemSyncDescriptor where ID == UUID, Response == PreviewResponse {
+
+    public static let orphan = Self( "orphan", loaderPath: \.orphan, upserterPath: \.orphan)
+}
diff --git a/app-core/Sources/AppCore/Catalogue/Sync/Loader.swift b/app-core/Sources/AppCore/Catalogue/Sync/Loader.swift
index 9c8a8cfd..9de1c6e4 100644
--- a/app-core/Sources/AppCore/Catalogue/Sync/Loader.swift
+++ b/app-core/Sources/AppCore/Catalogue/Sync/Loader.swift
@@ -13,9 +13,14 @@ import AppApi
 @MainActor @propertyWrapper
 public struct Loader<Input: Sendable, Response: Decodable & Sendable>: DynamicProperty {
 
-    @Environment(\.apiBaseURL) private var baseURL
-    @Environment(\.urlSession) private var session
-    @Environment(\.itemLoaders) private var loaders
+    @Environment(\.apiBaseURL)
+    private var baseURL
+    
+    @Environment(\.urlSession)
+    private var session
+    
+    @Environment(\.itemLoaders)
+    private var loaders
 
     private let path: KeyPath<CatalogueItemLoaders, @Sendable (URL, URLSession) -> RequestLoader<Input, Response>>
 
diff --git a/app-core/Sources/AppCore/Catalogue/Sync/Upserter.swift b/app-core/Sources/AppCore/Catalogue/Sync/Upserter.swift
index 6096e4b3..75daf309 100644
--- a/app-core/Sources/AppCore/Catalogue/Sync/Upserter.swift
+++ b/app-core/Sources/AppCore/Catalogue/Sync/Upserter.swift
@@ -7,39 +7,42 @@ import AppApi
 /// for a single catalogue item type.
 ///
 /// Reads `\.apiBaseURL`, `\.urlSession`, `\.itemLoaders`, `\.itemUpserters`, and `\.modelContext`
-/// from the environment. The `CatalogueItemSyncs` recipe links the loader factory to its typed
+/// from the environment. The `CatalogueItemSyncDescriptor` links the loader factory to its typed
 /// store upsert function, ensuring their `Response` type always matches.
 /// Returns a no-op syncer when `apiBaseURL` is not set (Personal app / unconfigured).
 ///
 /// Usage:
 /// ```swift
-/// @Upserter(\.song) var syncer     // CatalogueItemSyncer<Int>
-/// @Upserter(\.orphan) var syncer   // CatalogueItemSyncer<UUID>
+/// @Upserter(.song) var syncer     // CatalogueItemSyncer<Int>
+/// @Upserter(.orphan) var syncer   // CatalogueItemSyncer<UUID>
 /// ```
 @MainActor @propertyWrapper
 public struct Upserter<ID: Sendable, Response: Decodable & Sendable>: DynamicProperty {
 
     @Environment(\.apiBaseURL) private var baseURL
+    
     @Environment(\.urlSession) private var session
+    
     @Environment(\.itemLoaders) private var loaders
+    
     @Environment(\.itemUpserters) private var upserters
+    
     @Environment(\.modelContext) private var context
 
-    private let path: KeyPath<CatalogueItemSyncs, CatalogueItemSync<ID, Response>>
+    private let descriptor: CatalogueItemSyncDescriptor<ID, Response>
 
-    private static var syncs: CatalogueItemSyncs { .init() }
-
-    public init(_ path: KeyPath<CatalogueItemSyncs, CatalogueItemSync<ID, Response>>) {
-        self.path = path
+    public init(
+        _ descriptor: CatalogueItemSyncDescriptor<ID, Response>
+    )  {
+        self.descriptor = descriptor
     }
 
     public var wrappedValue: CatalogueItemSyncer<ID> {
-        guard let baseURL else { return .init() }   // Personal / unconfigured → no-op
-        let recipe = Self.syncs[keyPath: path]
-        let loader = loaders[keyPath: recipe.loaderPath](baseURL, session)
-        let upsert = upserters[keyPath: recipe.upserterPath]
+        guard let baseURL else { return .init() } 
+        let loader = loaders[keyPath: descriptor.loaderPath](baseURL, session)
+        let upsert = upserters[keyPath: descriptor.upserterPath]
         let store  = CatalogueStore(context: context)
-        return CatalogueItemSyncer { [label = recipe.label] id in
+        return CatalogueItemSyncer { [label = descriptor.label] id in
             try await Syncer(label, loader: loader, from: id) { try await upsert(store, $0) }.run()
         }
     }
diff --git a/app-core/Sources/AppCore/Catalogue/Views/CatalogueItemStatusLine.swift b/app-core/Sources/AppCore/Catalogue/Views/CatalogueItemStatusLine.swift
index 7fdb6fd6..a34e61ba 100644
--- a/app-core/Sources/AppCore/Catalogue/Views/CatalogueItemStatusLine.swift
+++ b/app-core/Sources/AppCore/Catalogue/Views/CatalogueItemStatusLine.swift
@@ -1,8 +1,8 @@
 import SwiftUI
 
 /// A non-disruptive one-liner row for a catalogue item detail screen.
-/// Parameterised twin of `CatalogueStatusLine` — same visuals, same states, but takes
-/// loading/lastError/lastFetched as direct inputs rather than reading from the catalogue model.
+/// Twin of `FeedStatusLine` — same visuals, same states, but takes loading/lastError/lastFetched
+/// as direct inputs rather than a `FeedModel` (item detail state isn't feed-backed).
 struct CatalogueItemStatusLine: View {
 
     let loading: LoadingState?
diff --git a/app-core/Sources/AppCore/Feed/Feed.swift b/app-core/Sources/AppCore/Feed/Feed.swift
new file mode 100644
index 00000000..1bd9a51a
--- /dev/null
+++ b/app-core/Sources/AppCore/Feed/Feed.swift
@@ -0,0 +1,31 @@
+import SwiftUI
+
+/// Reads the nearest feed's `FeedModel` — the counterpart of the parent's `.feed(_:)` call,
+/// which creates the model, wires its pipeline, and scopes it into the environment. A missing
+/// `.feed(_:)` ancestor fails fast with SwiftUI's missing-environment diagnostic.
+///
+/// Feeds are keyed by their `Input` type; name it either through the wrapped type or the
+/// initializer — whichever reads better at the site:
+/// ```swift
+/// // parent
+/// PostsList(query: query).feed(.posts)
+///
+/// // child — equivalent forms
+/// @Feed(PostsQuery.self) private var posts
+/// @Feed private var posts: FeedModel<PostsQuery>
+///
+/// .task(id: query) { await posts.fetch(query) }    // the input decides browse vs search
+/// ```
+@MainActor @propertyWrapper
+public struct Feed<Input: PageableQuery>: DynamicProperty {
+
+    @Environment(FeedModel<Input>.self)
+    private var model
+
+    public init() {}
+
+    /// Inference aid: names the feed by its `Input` type so the property needs no annotation.
+    public init(_ inputType: Input.Type) {}
+
+    public var wrappedValue: FeedModel<Input> { model }
+}
diff --git a/app-core/Sources/AppCore/Feed/FeedConfiguration.swift b/app-core/Sources/AppCore/Feed/FeedConfiguration.swift
new file mode 100644
index 00000000..50bcf205
--- /dev/null
+++ b/app-core/Sources/AppCore/Feed/FeedConfiguration.swift
@@ -0,0 +1,198 @@
+import SwiftUI
+import SwiftData
+import AppApi
+import AppPersistence
+import TmbrCore
+
+/// The recipe for one feed: its identity (`label`) and how to compose the network loader and
+/// store upsert into the fetch pipeline. Everything else the feed needs to drive itself comes
+/// from the `Input`'s own `PageableQuery` conformance.
+///
+/// The feature's parent view applies it with **one call** — `.feed(.posts)` — which owns the
+/// `FeedModel`, wires its pipeline from the environment (`apiBaseURL`, `urlSession`,
+/// `modelContext`), persists its freshness stamp (`userDefaults`), and scopes the model, its
+/// `FeedState`, and the control actions for the subtree. Children read the model back with
+/// `@Feed`, and components like `FeedStatusLine` read `\.feedState` / `\.loadFeed` /
+/// `\.retryFeed`.
+///
+/// Previews and tests pass a stub recipe instead:
+///
+/// ```swift
+/// PostsList(languages: [], searchText: "")
+///     .feed(FeedConfiguration(
+///         label: "posts",
+///         loader: { _, _ in PostsLoader { _ in PageResult(items: mockPosts, nextCursor: nil) } },
+///         upsert: { try PostStore(context: $0).upsert($1.items) },
+///         nextCursor: { $0.nextCursor }
+///     ))
+/// ```
+public struct FeedConfiguration<Input: PageableQuery>: Sendable {
+
+    /// Persistence key (`feed.<label>.lastFetched`) and log tag.
+    let label: String
+
+    /// Composes the feed's fetch pipeline — `Input → nextCursor`, upserting as a side effect —
+    /// from per-app config.
+    let makeFetch: @MainActor (URL, URLSession, ModelContext) -> (@MainActor (Input) async throws -> String?)
+
+    /// Raw composition — for feeds that aren't a paged loader+upsert pipeline (e.g. the
+    /// catalogue `SyncGroup` refresh). Prefer the typed initializer for paged endpoints.
+    public init(
+        label: String,
+        makeFetch: @escaping @MainActor (URL, URLSession, ModelContext) -> (@MainActor (Input) async throws -> String?)
+    ) {
+        self.label = label
+        self.makeFetch = makeFetch
+    }
+
+    /// Typed composition for a paged endpoint. Keeps the loader's `Response` and the upserter's
+    /// input matched at compile time; `Response` is erased into the composed fetch, so the
+    /// configuration stays generic over `Input` alone.
+    public init<Response: Decodable & Sendable>(
+        label: String,
+        loader: @escaping @Sendable (URL, URLSession) -> RequestLoader<Input, Response>,
+        upsert: @escaping @MainActor (ModelContext, Response) throws -> Void,
+        nextCursor: @escaping @Sendable (Response) -> String?
+    ) {
+        self.init(label: label) { baseURL, session, context in
+            let loader = loader(baseURL, session)
+            return { input in
+                let response = try await loader.load(from: input)
+                try upsert(context, response)
+                return nextCursor(response)
+            }
+        }
+    }
+}
+
+// MARK: - Feeds
+
+extension FeedConfiguration where Input == PostsQuery {
+
+    /// Blog posts — browse, search, and paging over `GET /api/posts` into `PostStore`.
+    public static var posts: Self {
+        FeedConfiguration(
+            label: "posts",
+            loader: { PostsLoader.posts(baseURL: $0, session: $1) },
+            upsert: { try PostStore(context: $0).upsert($1.items) },
+            nextCursor: { $0.nextCursor }
+        )
+    }
+}
+
+extension FeedConfiguration where Input == QuotesQuery {
+
+    /// Quotes — browse, search, and paging over `GET /api/quotes` into `CatalogueStore`.
+    public static var quotes: Self {
+        FeedConfiguration(
+            label: "quotes",
+            loader: { QuotesLoader.quotes(baseURL: $0, session: $1) },
+            upsert: { try CatalogueStore(context: $0).upsert($1.items) },
+            nextCursor: { $0.nextCursor }
+        )
+    }
+}
+
+extension FeedConfiguration where Input == CatalogueSearchQuery {
+
+    /// Catalogue search — search + paging over `GET /api/catalogue/search` (previews and notes)
+    /// into `CatalogueStore`. Search-only: browse refresh is the `.catalogue` feed.
+    public static var catalogueSearch: Self {
+        FeedConfiguration(
+            label: "catalogueSearch",
+            loader: { CatalogueSearchLoader.searchCatalogue(baseURL: $0, session: $1) },
+            upsert: { try CatalogueStore(context: $0).upsertSearch($1) },
+            nextCursor: { $0.nextCursor }
+        )
+    }
+}
+
+extension FeedConfiguration where Input == CatalogueSyncQuery {
+
+    /// Catalogue browse refresh — runs the full catalogue `SyncGroup` (typed lists + orphans +
+    /// categories). Not paged: the returned cursor is always `nil`, so `loadMore()` never fires.
+    public static var catalogue: Self {
+        FeedConfiguration(label: "catalogue") { baseURL, _, context in
+            let store = CatalogueStore(context: context)
+            return { _ in
+                try await SyncGroup.catalogue(baseURL: baseURL, store: store).run()
+                return nil
+            }
+        }
+    }
+}
+
+// MARK: - The one-call modifier
+
+/// Owns the `FeedModel` for one feed and provisions the subtree: wires the fetch pipeline from
+/// the environment, persists the freshness stamp, then scopes the model (for `@Feed`), its
+/// `FeedState`, and the control actions (for `FeedStatusLine` / `FeedLoadMoreCell` /
+/// `FeedEmptyView`).
+private struct FeedModifier<Input: PageableQuery>: ViewModifier {
+
+    @Environment(\.apiBaseURL)
+    private var baseURL
+
+    @Environment(\.urlSession)
+    private var session
+
+    @Environment(\.modelContext)
+    private var context
+
+    @Environment(\.userDefaults)
+    private var userDefaults
+
+    @State
+    private var model: FeedModel<Input>
+
+    private let configuration: FeedConfiguration<Input>
+
+    init(configuration: FeedConfiguration<Input>) {
+        self.configuration = configuration
+        self._model = State(wrappedValue: FeedModel(label: configuration.label))
+    }
+
+    func body(content: Content) -> some View {
+        wirePipeline()
+        return content
+            .environment(model)
+            .feedControls(model)
+            // The freshness stamp is persisted reactively — the model just records the date.
+            .onChange(of: model.state.lastFetched) { _, date in
+                guard let date else { return }
+                userDefaults.set(date, forKey: lastFetchedKey)
+            }
+    }
+
+    /// Re-composes the model's fetch pipeline from the current environment. Runs on every body
+    /// evaluation; the assigned properties are not observation-tracked, so this never
+    /// invalidates the view. (`apiBaseURL`, `urlSession`, and `userDefaults` are effectively
+    /// constant, so re-evaluations are rare and the work is assigning a closure.)
+    private func wirePipeline() {
+        guard let baseURL else {
+            model.pipeline = nil
+            return
+        }
+        model.pipeline = configuration.makeFetch(baseURL, session, context)
+        model.seed(lastFetched: userDefaults.object(forKey: lastFetchedKey) as? Date)
+    }
+
+    private var lastFetchedKey: String {
+        "feed.\(configuration.label).lastFetched"
+    }
+}
+
+public extension View {
+
+    /// Provisions a feed for this subtree with a single call: creates and owns its `FeedModel`,
+    /// wires the fetch pipeline, and scopes the model + state + control actions so descendants
+    /// can use `@Feed`, `FeedStatusLine`, `FeedLoadMoreCell`, and `FeedEmptyView` with no
+    /// further wiring.
+    ///
+    /// When one subtree hosts several feeds (e.g. catalogue browse + search), the shared
+    /// component keys (`\.feedState`, `\.loadFeed`, `\.retryFeed`) follow the innermost
+    /// `.feed(_:)` — re-scope explicitly with `.feedControls(_:)` where it matters.
+    func feed<Input>(_ configuration: FeedConfiguration<Input>) -> some View {
+        modifier(FeedModifier(configuration: configuration))
+    }
+}
diff --git a/app-core/Sources/AppCore/Feed/FeedEmptyView.swift b/app-core/Sources/AppCore/Feed/FeedEmptyView.swift
new file mode 100644
index 00000000..c213b335
--- /dev/null
+++ b/app-core/Sources/AppCore/Feed/FeedEmptyView.swift
@@ -0,0 +1,38 @@
+import SwiftUI
+
+/// Overlay shown when a feed-backed list is empty, switching on the current load state:
+/// a spinner while fetching, the typed error with a retry button after a failure, the standard
+/// "no results" while a search session is active — browse and search alike — and the caller's
+/// own idle-empty content otherwise (the feature's "nothing here yet").
+///
+/// Self-contained: reads the nearest feed's state from `\.feedState` and fires `\.retryFeed`
+/// (both scoped by `.feed(_:)` / `.feedControls(_:)`).
+struct FeedEmptyView<EmptyContent: View>: View {
+
+    @Environment(\.feedState)
+    private var state
+
+    @Environment(\.retryFeed)
+    private var retryFeed
+
+    @ViewBuilder
+    let emptyContent: () -> EmptyContent
+
+    var body: some View {
+        if state.loading == .refresh {
+            ProgressView()
+        } else if let error = state.lastError {
+            ContentUnavailableView {
+                Label(error.title, systemImage: error.systemImage)
+            } description: {
+                Text(error.message)
+            } actions: {
+                Button("Try Again") { Task { await retryFeed() } }
+            }
+        } else if state.isSearching {
+            ContentUnavailableView.search
+        } else {
+            emptyContent()
+        }
+    }
+}
diff --git a/app-core/Sources/AppCore/Feed/FeedEnvironment.swift b/app-core/Sources/AppCore/Feed/FeedEnvironment.swift
new file mode 100644
index 00000000..1386a590
--- /dev/null
+++ b/app-core/Sources/AppCore/Feed/FeedEnvironment.swift
@@ -0,0 +1,31 @@
+import SwiftUI
+
+public extension EnvironmentValues {
+
+    /// App-wide persisted-defaults store — injectable for tests/previews.
+    @Entry var userDefaults: UserDefaults = .standard
+
+    /// The nearest feed's observable UI state. Inert default; scoped by `.feedControls(_:retry:)`.
+    @Entry var feedState: FeedState = FeedState()
+
+    /// Loads the next page of the nearest feed's session.
+    @Entry var loadFeed: FeedPageLoadAction = FeedPageLoadAction()
+
+    /// Re-fires page 1 of the nearest feed's session.
+    @Entry var retryFeed: FeedRetryAction = FeedRetryAction()
+}
+
+public extension View {
+
+    /// Scopes a feed's observable state and control actions for descendant feed components
+    /// (`FeedStatusLine`, `FeedLoadMoreCell`, `FeedEmptyView`) — they read `\.feedState`,
+    /// `\.loadFeed`, and `\.retryFeed` instead of receiving a model through their initializers.
+    ///
+    /// `.feed(_:)` already applies this; call it directly only to re-scope a specific feed
+    /// where several coexist in one subtree (e.g. the catalogue's search load-more cell).
+    func feedControls<Input>(_ feed: FeedModel<Input>) -> some View where Input: PageableQuery {
+        environment(\.feedState, feed.state)
+            .environment(\.loadFeed, FeedPageLoadAction { await feed.loadMore() })
+            .environment(\.retryFeed, FeedRetryAction { await feed.retry() })
+    }
+}
diff --git a/app-core/Sources/AppCore/Feed/FeedLoadMoreCell.swift b/app-core/Sources/AppCore/Feed/FeedLoadMoreCell.swift
new file mode 100644
index 00000000..83fb1f60
--- /dev/null
+++ b/app-core/Sources/AppCore/Feed/FeedLoadMoreCell.swift
@@ -0,0 +1,35 @@
+import SwiftUI
+
+/// A list footer that owns the load-more trigger and loading spinner for a paged feed.
+///
+/// Self-contained: reads the nearest feed's state from `\.feedState` and fires `\.loadFeed`
+/// (both scoped by `.feedControls(_:retry:)`) the moment it appears — the model guards against
+/// redundant calls when `!hasMore`, no session exists yet, or a load is already in flight.
+/// Renders a centered `ProgressView` while paging, and an invisible placeholder otherwise so
+/// the `.onAppear` trigger stays in the list.
+struct FeedLoadMoreCell: View {
+
+    @Environment(\.feedState)
+    private var state
+
+    @Environment(\.loadFeed)
+    private var loadFeed
+
+    var body: some View {
+        Group {
+            if state.loading == .page {
+                HStack {
+                    Spacer()
+                    ProgressView()
+                    Spacer()
+                }
+            } else {
+                Color.clear.frame(height: 0)
+            }
+        }
+        .listRowSeparator(.hidden)
+        .onAppear {
+            Task { await loadFeed() }
+        }
+    }
+}
diff --git a/app-core/Sources/AppCore/Feed/FeedModel.swift b/app-core/Sources/AppCore/Feed/FeedModel.swift
new file mode 100644
index 00000000..8a47d7b4
--- /dev/null
+++ b/app-core/Sources/AppCore/Feed/FeedModel.swift
@@ -0,0 +1,228 @@
+import Foundation
+import OSLog
+
+/// The receipt of a committed fetch — everything the owning view needs to page further.
+/// `nil` in `FeedModel.fetch`'s return means the request did **not** commit (failed or
+/// superseded): keep your previous paging state so the same page can be retried.
+public struct FeedPage: Hashable, Sendable {
+
+    /// Cursor for the next page; `nil` = the feed has no more pages.
+    public let nextCursor: String?
+
+    /// The fetched frontier — the cursor as a date. Rows older than this are unverified local
+    /// cache; displaying one is the signal to fetch the next page. `nil` when the cursor
+    /// doesn't parse (the paging convenience still works via `loadMore()`).
+    public let frontier: Date?
+}
+
+/// Headless network behavior for one server-backed feed; the list renders from the local store,
+/// this model fetches + upserts (inside the pipeline) and publishes progress through `state`.
+///
+/// **The view is in control**: it constructs the endpoint's own `Input` and calls `fetch(_:)` —
+/// the input alone decides what happens, read through its `PageableQuery` conformance. A
+/// committed fetch returns a `FeedPage` receipt; the view stores it as its paging state, the
+/// source of truth.
+///
+/// The model keeps convenience copies of the session **only** for the self-contained controls,
+/// which can't construct an `Input`: `loadMore()` (`FeedLoadMoreCell`) and `retry()`
+/// (`FeedEmptyView`) — both sugar over `fetch(_:)`.
+///
+/// `pipeline` — the one injected seam — is assigned by the `.feed(_:)` modifier from its
+/// configuration. It stays `nil` when no `apiBaseURL` is configured (Personal app) — every
+/// operation no-ops.
+///
+/// `@Observable` solely so `.feed(_:)` can scope it by type and `@Feed` can read it back —
+/// every stored property is untracked; observable UI state lives in `state`.
+@MainActor
+@Observable
+public final class FeedModel<Input: PageableQuery> {
+
+    /// Observable UI state — scoped for feed components by `.feed(_:)` / `.feedControls(_:)`.
+    public let state = FeedState()
+
+    // MARK: - Session (convenience copies for the parameterless controls)
+
+    /// The active session: its input and latest receipt, as last successfully fetched —
+    /// `loadMore()` continues them.
+    @ObservationIgnored
+    private var activeInput: Input?
+
+    @ObservationIgnored
+    private var latestPage: FeedPage?
+
+    /// The last **attempted** page-1 input — recorded before the fetch, so a failed first
+    /// load is retryable. Continuations never touch it: a quiet page-3 failure must not
+    /// redefine what "Try Again" retries.
+    @ObservationIgnored
+    private var lastInput: Input?
+
+    /// The in-flight fetch. Page-1 requests cancel and replace it (supersede); a superseded
+    /// task touches no state and its caller converges on the successor's result, so a late
+    /// resumption can never overwrite a newer commit.
+    @ObservationIgnored
+    private var activeFetch: Task<Outcome, Never>?
+
+    // MARK: - The seam (assigned by the `.feed(_:)` modifier)
+
+    /// The composed fetch pipeline: `Input → nextCursor`, upserting into the local store as a
+    /// side effect. `nil` = no backend configured; all operations no-op.
+    @ObservationIgnored
+    var pipeline: (@MainActor (Input) async throws -> String?)?
+
+    /// Label used in log messages ("posts", "quotes", …).
+    @ObservationIgnored
+    private let label: String
+
+    public init(label: String = "feed") {
+        self.label = label
+    }
+
+    // MARK: - Fetch (the one entry point)
+
+    /// Fetches `input` — the input decides everything. Without a cursor it's a page-1 request:
+    /// fires immediately, **supersedes** whatever is in flight (last submitted input wins),
+    /// fails loudly, and browse additionally records `lastFetched`. With a cursor it's a
+    /// continuation: never interrupts (dropped while anything runs) and fails quietly — a
+    /// paging hiccup on a populated list shouldn't blank the screen.
+    ///
+    /// Returns the committed page's receipt for the view to store, or `nil` on failure —
+    /// keep your previous paging state in that case. A superseded call returns the **winning
+    /// request's** result instead of its own, so concurrent callers all assign the same truth
+    /// no matter the order they resume in.
+    @discardableResult
+    public func fetch(_ input: Input) async -> FeedPage? {
+        let firstPage = input.cursor == nil
+        if firstPage {
+            lastInput = input
+            state.isSearching = input.isSearch
+        }
+        guard pipeline != nil else { return nil }
+        if firstPage {
+            activeFetch?.cancel()
+        } else if state.loading != nil {
+            return nil
+        }
+        state.loading = firstPage ? .refresh : .page
+
+        let task = Task { await perform(input) }
+        activeFetch = task
+
+        // Converge on the winner: a superseded request hands back its successor's result, so
+        // every concurrent caller assigns the same receipt no matter when it resumes — a stale
+        // `nil` can never overwrite a newer commit.
+        var awaited = task
+        var outcome = await awaited.value
+        while case .superseded = outcome, let successor = activeFetch, successor != awaited {
+            awaited = successor
+            outcome = await awaited.value
+        }
+        return outcome.page
+    }
+
+    // MARK: - Session continuations (sugar over fetch, for the parameterless controls)
+
+    /// Fetches the next page of the active session — the same input, threaded with the last
+    /// fresh cursor. Exists for self-contained controls (`FeedLoadMoreCell`) that can't
+    /// construct an `Input` themselves.
+    public func loadMore() async {
+        guard state.loading == nil, state.hasMore,
+              let input = activeInput, let cursor = latestPage?.nextCursor else { return }
+        await fetch(input.page(after: cursor))
+    }
+
+    /// Re-fires the last attempted page-1 input — the input re-classifies itself, so this works
+    /// for browse and search alike. No-op before the first attempt.
+    public func retry() async {
+        guard let lastInput else { return }
+        await fetch(lastInput)
+    }
+
+    // MARK: - Execution
+
+    /// What became of a fetch.
+    private enum Outcome {
+        /// Committed — carries the receipt.
+        case fetched(FeedPage)
+        /// Failed for real (not a cancellation); already logged and surfaced.
+        case failed
+        /// Cancelled because a newer page-1 request took over — no state was touched.
+        case superseded
+
+        var page: FeedPage? {
+            if case .fetched(let page) = self { page } else { nil }
+        }
+    }
+
+    /// The tracked unit of work: pipeline → commit → state updates, run as `activeFetch`.
+    /// Every form of cancellation becomes `.superseded`, and a superseded run touches no
+    /// state — the successor owns it all.
+    private func perform(_ input: Input) async -> Outcome {
+        guard let pipeline else { return .superseded }
+        let firstPage = input.cursor == nil
+        do {
+            let nextCursor = try await pipeline(input)
+            guard !Task.isCancelled else { return .superseded }
+            let page = commit(input: input, nextCursor: nextCursor)
+            if firstPage {
+                state.lastError = nil
+                if !input.isSearch { state.lastFetched = .now }
+            }
+            state.loading = nil
+            return .fetched(page)
+        } catch {
+            if Task.isCancelled || Self.isCancellation(error) { return .superseded }
+            Logger.feed.error("Feed '\(self.label)' fetch failed: \(error)")
+            if firstPage {
+                state.lastError = LoadError(error)
+                if input.isSearch { state.hasMore = false }
+            }
+            state.loading = nil
+            return .failed
+        }
+    }
+
+    // MARK: - Bookkeeping
+
+    /// Commits a fetched page: remembers the session for `loadMore()`, settles `hasMore`, and
+    /// bumps `revision` so manual store readers re-query. Returns the view's receipt.
+    private func commit(input: Input, nextCursor: String?) -> FeedPage {
+        let page = FeedPage(
+            nextCursor: nextCursor,
+            frontier: nextCursor.flatMap { raw in
+                (try? Date(raw, strategy: .iso8601))
+                    ?? (try? Date(raw, strategy: Date.ISO8601FormatStyle(includingFractionalSeconds: true)))
+            }
+        )
+        activeInput = input
+        latestPage = page
+        state.hasMore = nextCursor != nil
+        state.revision += 1
+        return page
+    }
+
+    /// Seeds `lastFetched` from persisted storage — a no-op once any value exists, so a live
+    /// refresh is never overwritten by a stale stored date.
+    func seed(lastFetched date: Date?) {
+        guard state.lastFetched == nil, let date else { return }
+        state.lastFetched = date
+    }
+
+    private static func isCancellation(_ error: Error) -> Bool {
+        if error is CancellationError { return true }
+        if let urlError = error as? URLError, urlError.code == .cancelled { return true }
+        return false
+    }
+}
+
+extension FeedModel where Input == CatalogueSyncQuery {
+
+    /// Fetch sugar for the input-less `.catalogue` sync feed.
+    @discardableResult
+    public func fetch() async -> FeedPage? {
+        await fetch(CatalogueSyncQuery())
+    }
+}
+
+extension Logger {
+    static let feed = Logger(subsystem: "me.tmbr", category: "feed")
+}
diff --git a/app-core/Sources/AppCore/Feed/FeedPageLoadAction.swift b/app-core/Sources/AppCore/Feed/FeedPageLoadAction.swift
new file mode 100644
index 00000000..ced5c6cd
--- /dev/null
+++ b/app-core/Sources/AppCore/Feed/FeedPageLoadAction.swift
@@ -0,0 +1,15 @@
+import Foundation
+
+/// Loads the next page of the active feed session — the env-injected seam behind
+/// `FeedLoadMoreCell`. Wired by `.feedControls(_:retry:)` to the owning feed's `loadMore()`.
+@MainActor
+public struct FeedPageLoadAction: Sendable {
+
+    private let body: @MainActor () async -> Void
+
+    nonisolated public init(_ body: @escaping @MainActor () async -> Void = {}) {
+        self.body = body
+    }
+
+    public func callAsFunction() async { await body() }
+}
diff --git a/app-core/Sources/AppCore/Feed/FeedRetryAction.swift b/app-core/Sources/AppCore/Feed/FeedRetryAction.swift
new file mode 100644
index 00000000..be271640
--- /dev/null
+++ b/app-core/Sources/AppCore/Feed/FeedRetryAction.swift
@@ -0,0 +1,16 @@
+import Foundation
+
+/// Re-fires page 1 of the active feed session — the env-injected seam behind `FeedEmptyView`'s
+/// "Try Again" button. Wired by `.feedControls(_:retry:)`; the owning list supplies the closure
+/// so retry re-runs whichever mode is active (browse refresh or search).
+@MainActor
+public struct FeedRetryAction: Sendable {
+
+    private let body: @MainActor () async -> Void
+
+    nonisolated public init(_ body: @escaping @MainActor () async -> Void = {}) {
+        self.body = body
+    }
+
+    public func callAsFunction() async { await body() }
+}
diff --git a/app-core/Sources/AppCore/Feed/FeedState.swift b/app-core/Sources/AppCore/Feed/FeedState.swift
new file mode 100644
index 00000000..5d44eb48
--- /dev/null
+++ b/app-core/Sources/AppCore/Feed/FeedState.swift
@@ -0,0 +1,44 @@
+import Foundation
+
+/// Which load operation is currently in flight, if any.
+public enum LoadingState: Equatable, Sendable {
+    case refresh
+    case page
+}
+
+/// Observable UI state of one feed — everything feed components render from.
+///
+/// Non-generic on purpose: components like `FeedStatusLine` and `FeedLoadMoreCell` read it via
+/// `\.feedState` without caring which feed (or `Input` type) they serve. The owning list scopes
+/// it — together with the control actions — via `.feedControls(_:retry:)`. `FeedModel` is the
+/// only writer.
+///
+/// Reads are tracked per property by Observation: a view reading only `loading` re-renders only
+/// when `loading` changes.
+@MainActor
+@Observable
+public final class FeedState {
+
+    /// Which load operation is currently in flight; `nil` when idle.
+    public internal(set) var loading: LoadingState?
+
+    /// Whether the active session is a search (`search(_:)` was the last page-1 request)
+    /// rather than browse. Drives search-specific presentation, e.g. `FeedEmptyView`'s
+    /// "no results" state.
+    public internal(set) var isSearching = false
+
+    /// `false` once a fetch returns no cursor, meaning there are no more pages to load.
+    public internal(set) var hasMore = true
+
+    /// The error from the last refresh/search attempt; `nil` after a success.
+    public internal(set) var lastError: LoadError?
+
+    /// When the last successful refresh completed. Seeded from persisted storage by `@Feed`.
+    public internal(set) var lastFetched: Date?
+
+    /// Increments after every successful fetch+upsert. Views that read the store manually
+    /// (e.g. `CatalogueSearchEngine`) observe this to re-run their local query.
+    public internal(set) var revision = 0
+
+    nonisolated public init() {}
+}
diff --git a/app-core/Sources/AppCore/Feed/FeedStatusLine.swift b/app-core/Sources/AppCore/Feed/FeedStatusLine.swift
new file mode 100644
index 00000000..dd5b8f14
--- /dev/null
+++ b/app-core/Sources/AppCore/Feed/FeedStatusLine.swift
@@ -0,0 +1,41 @@
+import SwiftUI
+
+/// A non-disruptive one-liner row shown at the top of a populated feed list.
+/// Displays refresh activity, a failure indicator, or the last-updated time.
+///
+/// Self-contained: reads the nearest feed's state from `\.feedState` (scoped by
+/// `.feedControls(_:retry:)`). Uses `Text(date, format:)` for relative dates so the time
+/// auto-updates while on screen.
+struct FeedStatusLine: View {
+
+    @Environment(\.feedState)
+    private var state
+
+    var body: some View {
+        statusContent
+            .font(.caption)
+            .foregroundStyle(.secondary)
+            .listRowSeparator(.hidden)
+            .listRowBackground(Color.clear)
+    }
+
+    @ViewBuilder
+    private var statusContent: some View {
+        if state.loading == .refresh {
+            Label("Updating\u{2026}", systemImage: "arrow.clockwise")
+        } else if state.lastError != nil {
+            if let date = state.lastFetched {
+                Label {
+                    Text("Couldn't update \u{00B7} \(date, format: .relative(presentation: .named))")
+                } icon: {
+                    Image(systemName: "exclamationmark.circle")
+                }
+            } else {
+                Label("Couldn't update", systemImage: "exclamationmark.circle")
+            }
+        } else if let date = state.lastFetched {
+            Text("Updated \(date, format: .relative(presentation: .named))")
+        }
+        // else: EmptyView — no status to show yet
+    }
+}
diff --git a/app-core/Sources/AppCore/Feed/FilterMapping.swift b/app-core/Sources/AppCore/Feed/FilterMapping.swift
new file mode 100644
index 00000000..1594941e
--- /dev/null
+++ b/app-core/Sources/AppCore/Feed/FilterMapping.swift
@@ -0,0 +1,34 @@
+import Foundation
+import TmbrCore
+import AppPersistence
+
+// The tab views translate their filter selections into API query parameter values when
+// constructing feed inputs (`PostsQuery`, `QuotesQuery`, `CatalogueSearchQuery`).
+
+extension Set where Element == Language {
+    /// Language codes for API query parameters; `nil` when no filter is active.
+    var apiValues: [String]? {
+        isEmpty ? nil : map(\.rawValue).sorted()
+    }
+}
+
+extension Set where Element == QuoteSourceFilter {
+    /// Source buckets for API query parameters — category slugs plus the `blog_posts`
+    /// sentinel; `nil` when no filter is active.
+    var apiValues: [String]? {
+        guard !isEmpty else { return nil }
+        return map { source in
+            switch source {
+            case .category(let category): category.slug
+            case .blogPosts: "blog_posts"
+            }
+        }.sorted()
+    }
+}
+
+extension Set where Element == CatalogueCategory {
+    /// Category slugs for API query parameters; `nil` when no filter is active.
+    var apiValues: [String]? {
+        isEmpty ? nil : map(\.slug).sorted()
+    }
+}
diff --git a/app-core/Sources/AppCore/Feed/PageableQuery.swift b/app-core/Sources/AppCore/Feed/PageableQuery.swift
new file mode 100644
index 00000000..75916be4
--- /dev/null
+++ b/app-core/Sources/AppCore/Feed/PageableQuery.swift
@@ -0,0 +1,43 @@
+import Foundation
+import TmbrCore
+
+/// What a feed's `Input` must expose for `FeedModel` to drive it — the domain query *is* the
+/// paging model: a term makes it a search session, a cursor makes it a continuation, and
+/// `page(after:)` points it at the next page. Conforming here is what used to be three
+/// injected closures.
+public protocol PageableQuery: Sendable {
+
+    /// Whether this query filters by a search term (search session) rather than browsing.
+    var isSearch: Bool { get }
+
+    /// The next-page cursor baked into this query, if any — non-nil marks a continuation.
+    var cursor: String? { get }
+
+    /// The same query pointed at the next page — cursor replaced, everything else preserved.
+    func page(after cursor: String) -> Self
+}
+
+extension PostsQuery: PageableQuery {
+    public var isSearch: Bool { term != nil }
+}
+
+extension QuotesQuery: PageableQuery {
+    public var isSearch: Bool { term != nil }
+}
+
+extension CatalogueSearchQuery: PageableQuery {
+    public var isSearch: Bool { true }      // the endpoint always searches
+}
+
+/// The input of the `.catalogue` sync feed — the `SyncGroup` refresh takes no parameters, so
+/// this is an empty token: never a search, never paged.
+public struct CatalogueSyncQuery: PageableQuery, Hashable {
+
+    public init() {}
+
+    public var isSearch: Bool { false }
+
+    public var cursor: String? { nil }
+
+    public func page(after cursor: String) -> Self { self }
+}
diff --git a/app-core/Sources/AppCore/Feed/SyncGroup+Catalogue.swift b/app-core/Sources/AppCore/Feed/SyncGroup+Catalogue.swift
new file mode 100644
index 00000000..ca016c5d
--- /dev/null
+++ b/app-core/Sources/AppCore/Feed/SyncGroup+Catalogue.swift
@@ -0,0 +1,74 @@
+import Foundation
+import AppApi
+import AppPersistence
+import TmbrCore
+
+extension SyncGroup {
+    /// Standard catalogue sync: fetches the six typed lists + orphans + categories from
+    /// `baseURL` and upserts each result into `store`. Runs all in parallel with partial-success
+    /// semantics — individual endpoint failures are logged and surfaced without discarding
+    /// successes. Backs the `.catalogue` feed's refresh.
+    static func catalogue(baseURL: URL, store: CatalogueStore) -> SyncGroup {
+        let page = PageQuery(limit: 50)
+        return SyncGroup(
+            [
+                Syncer(
+                    "songs",
+                    loader: .songs(baseURL: baseURL),
+                    from: page
+                ) {
+                    try await store.upsert($0)
+                },
+                Syncer(
+                    "albums",
+                    loader: .albums(baseURL: baseURL),
+                    from: page
+                ) {
+                    try await store.upsert($0)
+                },
+                Syncer(
+                    "books",
+                    loader: .books(baseURL: baseURL),
+                    from: page
+                ) {
+                    try await store.upsert($0)
+                },
+                Syncer(
+                    "movies",
+                    loader: .movies(baseURL: baseURL),
+                    from: page
+                ) {
+                    try await store.upsert($0)
+                },
+                Syncer(
+                    "podcasts",
+                    loader: .podcasts(baseURL: baseURL),
+                    from: page
+                ) {
+                    try await store.upsert($0)
+                },
+                Syncer(
+                    "playlists",
+                    loader: .playlists(baseURL: baseURL),
+                    from: page
+                ) {
+                    try await store.upsert($0)
+                },
+                Syncer(
+                    "orphans",
+                    loader: .orphans(baseURL: baseURL),
+                    from: OrphanPageQuery(limit: 50)
+                ) {
+                    try await store.upsertOrphans($0)
+                },
+                Syncer(
+                    "categories",
+                    loader: .categories(baseURL: baseURL),
+                    from: ()
+                ) {
+                    try await store.replaceCategories($0)
+                },
+            ]
+        )
+    }
+}
diff --git a/app-core/Sources/AppCore/Preferences/View+Preferences.swift b/app-core/Sources/AppCore/Preferences/View+Preferences.swift
index 6f3cc687..a2822bf5 100644
--- a/app-core/Sources/AppCore/Preferences/View+Preferences.swift
+++ b/app-core/Sources/AppCore/Preferences/View+Preferences.swift
@@ -3,11 +3,11 @@ import SwiftUI
 public extension View {
     /// Injects the Preferences model and its language-selection action into the view subtree.
     ///
-    /// Call this once at the composition root alongside `.blog(_:)` and `.catalogue(_:)`:
+    /// Call this once at the composition root alongside `.catalogue(_:)` and `.quotes(_:)`:
     /// ```swift
     /// ContentView()
-    ///     .blog(blog)
     ///     .catalogue(catalogue)
+    ///     .quotes(quotes)
     ///     .preferences(preferences)
     /// ```
     func preferences(_ model: PreferencesModel) -> some View {
diff --git a/app-core/Sources/AppCore/Shared/LoadError.swift b/app-core/Sources/AppCore/Shared/LoadError.swift
index ab4c8f73..c46d3a99 100644
--- a/app-core/Sources/AppCore/Shared/LoadError.swift
+++ b/app-core/Sources/AppCore/Shared/LoadError.swift
@@ -1,6 +1,6 @@
 import Foundation
 
-/// Typed failure cause for a background refresh. Carried by `BlogModel.lastError` so views can vary
+/// Typed failure cause for a background refresh. Carried by `FeedModel.lastError` so views can vary
 /// their icon and copy per cause rather than showing a generic error string.
 public enum LoadError: Error, Equatable, Sendable {
     case offline
diff --git a/app-core/Sources/AppCore/Shared/Log.swift b/app-core/Sources/AppCore/Shared/Log.swift
index 782b22e0..61d8daf9 100644
--- a/app-core/Sources/AppCore/Shared/Log.swift
+++ b/app-core/Sources/AppCore/Shared/Log.swift
@@ -3,4 +3,5 @@ import OSLog
 extension Logger {
     static let blog = Logger(subsystem: "me.tmbr", category: "blog")
     static let catalogue = Logger(subsystem: "me.tmbr", category: "catalogue")
+    static let quotes = Logger(subsystem: "me.tmbr", category: "quotes")
 }
diff --git a/app-core/Tests/CoreAppTests/CatalogueItemSyncSeamTests.swift b/app-core/Tests/CoreAppTests/CatalogueItemSyncSeamTests.swift
index 046820c4..6f057bcb 100644
--- a/app-core/Tests/CoreAppTests/CatalogueItemSyncSeamTests.swift
+++ b/app-core/Tests/CoreAppTests/CatalogueItemSyncSeamTests.swift
@@ -3,6 +3,7 @@ import Foundation
 import SwiftData
 import TmbrCore
 import AppApi
+import AppPersistence
 @testable import AppCore
 
 @MainActor
@@ -43,13 +44,13 @@ struct CatalogueItemSyncSeamTests {
         let pid = UUID()
         let stub = stubSong(previewID: pid, id: 42)
 
-        let recipe = CatalogueItemSyncs().song
+        let descriptor = CatalogueItemSyncDescriptor<Int, SongResponse>.song
         let loaders = CatalogueItemLoaders(song: { _, _ in SongItemLoader { _ in stub } })
         let upserters = CatalogueItemUpserters()
-        let loader = loaders[keyPath: recipe.loaderPath](URL(string: "https://test")!, .shared)
-        let upsert = upserters[keyPath: recipe.upserterPath]
+        let loader = loaders[keyPath: descriptor.loaderPath](URL(string: "https://test")!, .shared)
+        let upsert = upserters[keyPath: descriptor.upserterPath]
         let store = CatalogueStore(context: ctx)
-        let syncer = CatalogueItemSyncer<Int> { [label = recipe.label] id in
+        let syncer = CatalogueItemSyncer<Int> { [label = descriptor.label] id in
             try await Syncer(label, loader: loader, from: id) { try await upsert(store, $0) }.run()
         }
 
@@ -68,13 +69,13 @@ struct CatalogueItemSyncSeamTests {
         let stub = stubSong(previewID: pid, id: 7)
 
         var received: SongResponse?
-        let recipe = CatalogueItemSyncs().song
+        let descriptor = CatalogueItemSyncDescriptor<Int, SongResponse>.song
         let loaders = CatalogueItemLoaders(song: { _, _ in SongItemLoader { _ in stub } })
         let upserters = CatalogueItemUpserters(song: { _, response in received = response })
-        let loader = loaders[keyPath: recipe.loaderPath](URL(string: "https://test")!, .shared)
-        let upsert = upserters[keyPath: recipe.upserterPath]
+        let loader = loaders[keyPath: descriptor.loaderPath](URL(string: "https://test")!, .shared)
+        let upsert = upserters[keyPath: descriptor.upserterPath]
         let store = CatalogueStore(context: ctx)
-        let syncer = CatalogueItemSyncer<Int> { [label = recipe.label] id in
+        let syncer = CatalogueItemSyncer<Int> { [label = descriptor.label] id in
             try await Syncer(label, loader: loader, from: id) { try await upsert(store, $0) }.run()
         }
 
diff --git a/app-core/Tests/CoreAppTests/CatalogueUpsertTests.swift b/app-core/Tests/CoreAppTests/CatalogueUpsertTests.swift
index 7ccbbb19..48ac4f0e 100644
--- a/app-core/Tests/CoreAppTests/CatalogueUpsertTests.swift
+++ b/app-core/Tests/CoreAppTests/CatalogueUpsertTests.swift
@@ -2,6 +2,7 @@ import Testing
 import Foundation
 import SwiftData
 import TmbrCore
+import AppPersistence
 @testable import AppCore
 
 @MainActor
diff --git a/app-core/Tests/CoreAppTests/FeedModelTests.swift b/app-core/Tests/CoreAppTests/FeedModelTests.swift
new file mode 100644
index 00000000..0c798e6b
--- /dev/null
+++ b/app-core/Tests/CoreAppTests/FeedModelTests.swift
@@ -0,0 +1,431 @@
+import Testing
+import Foundation
+@testable import AppCore
+
+@MainActor
+@Suite("FeedModel")
+struct FeedModelTests {
+
+    // MARK: - Helpers
+
+    /// Minimal typed input standing in for PostsQuery/QuotesQuery/…
+    private struct TestQuery: PageableQuery, Hashable {
+        var term: String?
+        var filter: String?
+        var cursor: String?
+
+        var isSearch: Bool { term != nil }
+
+        func page(after cursor: String) -> Self {
+            var query = self
+            query.cursor = cursor
+            return query
+        }
+    }
+
+    private func makeModel(
+        fetch: (@MainActor (TestQuery) async throws -> String?)? = { _ in nil }
+    ) -> FeedModel<TestQuery> {
+        let model = FeedModel<TestQuery>(label: "test")
+        model.pipeline = fetch
+        return model
+    }
+
+    // MARK: - Initial state & seeding
+
+    @Test func initialLoadingIsNil() {
+        #expect(makeModel().state.loading == nil)
+    }
+
+    @Test func initialLastFetchedIsNil() {
+        #expect(makeModel().state.lastFetched == nil)
+    }
+
+    @Test func seedSetsLastFetchedWhenEmpty() {
+        let date = Date(timeIntervalSince1970: 1_000_000)
+        let model = makeModel()
+        model.seed(lastFetched: date)
+        #expect(model.state.lastFetched == date)
+    }
+
+    @Test func seedNeverOverridesAnExistingValue() async {
+        let stale = Date(timeIntervalSince1970: 1_000_000)
+        let model = makeModel(fetch: { _ in nil })
+        await model.fetch(TestQuery())
+        let live = model.state.lastFetched
+        model.seed(lastFetched: stale)
+        #expect(model.state.lastFetched == live)
+    }
+
+    // MARK: - No backend (fetch == nil)
+
+    @Test func allOperationsNoOpWithoutFetch() async {
+        let model = makeModel(fetch: nil)
+        await model.fetch(TestQuery())
+        await model.fetch(TestQuery(term: "swift"))
+        await model.loadMore()
+        #expect(model.state.lastFetched == nil)
+        #expect(model.state.lastError == nil)
+        #expect(model.state.revision == 0)
+    }
+
+    // MARK: - refresh() success
+
+    @Test func refreshSuccessSetsLastFetched() async {
+        let model = makeModel(fetch: { _ in nil })
+        await model.fetch(TestQuery())
+        #expect(model.state.lastFetched != nil)
+    }
+
+    @Test func refreshSuccessClearsLastError() async {
+        let model = makeModel(fetch: { _ in throw LoadError.offline })
+        await model.fetch(TestQuery())
+        #expect(model.state.lastError != nil)
+        model.pipeline = { _ in nil }
+        await model.fetch(TestQuery())
+        #expect(model.state.lastError == nil)
+    }
+
+    @Test func refreshSettlesHasMoreFromCursor() async {
+        let model = makeModel(fetch: { _ in nil })
+        await model.fetch(TestQuery())
+        #expect(!model.state.hasMore)
+        model.pipeline = { _ in "next" }
+        await model.fetch(TestQuery())
+        #expect(model.state.hasMore)
+    }
+
+    @Test func refreshBumpsRevision() async {
+        let model = makeModel(fetch: { _ in nil })
+        await model.fetch(TestQuery())
+        #expect(model.state.revision == 1)
+    }
+
+    @Test func refreshLoadingIsNilAfterCompletion() async {
+        let model = makeModel(fetch: { _ in nil })
+        await model.fetch(TestQuery())
+        #expect(model.state.loading == nil)
+    }
+
+    // MARK: - refresh() failure
+
+    @Test func refreshFailureSetsLastError() async {
+        let model = makeModel(fetch: { _ in throw LoadError.offline })
+        await model.fetch(TestQuery())
+        #expect(model.state.lastError == .offline)
+    }
+
+    @Test func refreshFailurePreservesLastFetched() async {
+        let prior = Date(timeIntervalSince1970: 1_000_000)
+        let model = makeModel(fetch: { _ in throw LoadError.offline })
+        model.seed(lastFetched: prior)
+        await model.fetch(TestQuery())
+        #expect(model.state.lastFetched == prior)
+    }
+
+    @Test func refreshFailurePreservesActiveSession() async {
+        // A failed refresh must not clobber the previous session — load-more can continue it.
+        var received: TestQuery?
+        let model = makeModel(fetch: { query in
+            received = query
+            return query.cursor == nil ? "page-2" : nil
+        })
+        await model.fetch(TestQuery(filter: "en"))
+        model.pipeline = { _ in throw LoadError.offline }
+        await model.fetch(TestQuery(filter: "hu"))
+        model.pipeline = { query in
+            received = query
+            return nil
+        }
+        await model.loadMore()
+        #expect(received?.cursor == "page-2")
+        #expect(received?.filter == "en")
+    }
+
+    @Test func refreshFailureDoesNotBumpRevision() async {
+        let model = makeModel(fetch: { _ in throw LoadError.offline })
+        await model.fetch(TestQuery())
+        #expect(model.state.revision == 0)
+    }
+
+    @Test func refreshFailureLoadingIsNilAfterCompletion() async {
+        let model = makeModel(fetch: { _ in throw LoadError.offline })
+        await model.fetch(TestQuery())
+        #expect(model.state.loading == nil)
+    }
+
+    // MARK: - search()
+
+    @Test func searchPassesInputVerbatim() async {
+        var received: TestQuery?
+        let model = makeModel(fetch: { query in
+            received = query
+            return nil
+        })
+        await model.fetch(TestQuery(term: "swift", filter: "en"))
+        #expect(received?.term == "swift")
+        #expect(received?.filter == "en")
+        #expect(received?.cursor == nil)
+    }
+
+    @Test func searchFailureSetsLastErrorAndStopsPaging() async {
+        let model = makeModel(fetch: { _ in throw LoadError.offline })
+        await model.fetch(TestQuery(term: "swift"))
+        #expect(model.state.lastError == .offline)
+        #expect(!model.state.hasMore)
+    }
+
+    @Test func searchBumpsRevision() async {
+        let model = makeModel(fetch: { _ in nil })
+        await model.fetch(TestQuery(term: "swift"))
+        #expect(model.state.revision == 1)
+    }
+
+    // MARK: - loadMore() session threading
+
+    @Test func loadMoreThreadsCursorIntoSessionInput() async {
+        var received: TestQuery?
+        let model = makeModel(fetch: { query in
+            received = query
+            return query.cursor == nil ? "page-2" : nil
+        })
+        await model.fetch(TestQuery(term: "swift", filter: "hu"))
+        await model.loadMore()
+        #expect(received?.term == "swift")
+        #expect(received?.filter == "hu")
+        #expect(received?.cursor == "page-2")
+    }
+
+    @Test func refreshAfterSearchStartsANewSession() async {
+        var received: TestQuery?
+        let model = makeModel(fetch: { query in
+            received = query
+            return "next"
+        })
+        await model.fetch(TestQuery(term: "swift"))
+        await model.fetch(TestQuery())
+        await model.loadMore()
+        #expect(received?.term == nil)
+        #expect(received?.cursor == "next")
+    }
+
+    // MARK: - loadMore() outcomes
+
+    @Test func loadMoreSetsHasMoreFalseWhenNoCursorRemains() async {
+        let model = makeModel(fetch: { query in query.cursor == nil ? "page-2" : nil })
+        await model.fetch(TestQuery())
+        #expect(model.state.hasMore)
+        await model.loadMore()
+        #expect(!model.state.hasMore)
+    }
+
+    @Test func loadMoreKeepsHasMoreTrueWhenCursorRemains() async {
+        let model = makeModel(fetch: { _ in "next" })
+        await model.fetch(TestQuery())
+        await model.loadMore()
+        #expect(model.state.hasMore)
+    }
+
+    @Test func loadMoreBumpsRevision() async {
+        let model = makeModel(fetch: { _ in "next" })
+        await model.fetch(TestQuery())
+        await model.loadMore()
+        #expect(model.state.revision == 2)
+    }
+
+    @Test func loadingIsNilAfterLoadMoreCompletes() async {
+        let model = makeModel(fetch: { _ in "next" })
+        await model.fetch(TestQuery())
+        await model.loadMore()
+        #expect(model.state.loading == nil)
+    }
+
+    // MARK: - loadMore() guards
+
+    @Test func loadMoreWithoutPriorFetchIsNoOp() async {
+        var callCount = 0
+        let model = makeModel(fetch: { @MainActor _ in
+            callCount += 1
+            return nil
+        })
+        await model.loadMore()      // no session yet — cold start
+        #expect(callCount == 0)
+    }
+
+    @Test func loadMoreBlockedWhenHasMoreIsFalse() async {
+        var callCount = 0
+        let model = makeModel(fetch: { @MainActor query in
+            callCount += 1
+            return query.cursor == nil ? "page-2" : nil
+        })
+        await model.fetch(TestQuery())
+        await model.loadMore()      // runs, returns nil cursor → hasMore = false
+        await model.loadMore()      // blocked
+        #expect(callCount == 2)
+    }
+
+    @Test func loadMoreErrorIsSwallowedAndDoesNotSetLastError() async {
+        let model = makeModel(fetch: { query in
+            if query.cursor == nil { return "page-2" }
+            throw LoadError.offline
+        })
+        await model.fetch(TestQuery())
+        await model.loadMore()
+        #expect(model.state.lastError == nil)
+        #expect(model.state.hasMore)      // untouched — user can retry
+    }
+
+    // MARK: - Cursored inputs (continuations by shape)
+
+    @Test func cursoredInputIsAQuietContinuation() async {
+        // A cursor in the input marks a continuation regardless of who built it:
+        // failures stay silent and the retryable page-1 input is not redefined.
+        let model = makeModel(fetch: { query in
+            if query.cursor != nil { throw LoadError.offline }
+            return "page-2"
+        })
+        await model.fetch(TestQuery(filter: "en"))
+        await model.fetch(TestQuery(filter: "en", cursor: "page-2"))
+        #expect(model.state.lastError == nil)
+        #expect(model.state.loading == nil)
+
+        var received: TestQuery?
+        model.pipeline = { query in
+            received = query
+            return nil
+        }
+        await model.retry()
+        #expect(received?.cursor == nil)    // retry re-fires page 1, not the failed page
+    }
+
+    // MARK: - Session mode
+
+    @Test func sessionModeTracksLastRequest() async {
+        let model = makeModel(fetch: { _ in nil })
+        #expect(!model.state.isSearching)
+        await model.fetch(TestQuery(term: "swift"))
+        #expect(model.state.isSearching)
+        await model.fetch(TestQuery())
+        #expect(!model.state.isSearching)
+    }
+
+    // MARK: - Superseding (page-1 requests fire immediately, last writer wins)
+
+    @Test func newSearchSupersedesInFlightRequest() async {
+        let model = makeModel()
+        model.pipeline = { [state = model.state] query in
+            if query.term == "old" {
+                // Worst-case interleaving: suspend until superseded, then keep suspending
+                // until the winner has committed, and only then exit the way a cancelled
+                // URLSession does — the loser resumes *after* the winner.
+                while !Task.isCancelled { await Task.yield() }
+                while state.revision == 0 { await Task.yield() }
+                throw CancellationError()
+            }
+            return "new-cursor"
+        }
+
+        let first = Task { await model.fetch(TestQuery(term: "old")) }
+        while model.state.loading == nil { await Task.yield() }    // "old" is now in flight
+        let winner = await model.fetch(TestQuery(term: "new"))
+        #expect(winner?.nextCursor == "new-cursor")
+
+        // The superseded request converges on the winner's receipt — a late resumption can
+        // never hand the view a stale nil — and surfaced nothing.
+        let superseded = await first.value
+        #expect(superseded == winner)
+        #expect(model.state.lastError == nil)
+        #expect(model.state.loading == nil)
+        #expect(model.state.hasMore)
+
+        // …and the session belongs to "new": load-more continues it.
+        var received: TestQuery?
+        model.pipeline = { query in
+            received = query
+            return nil
+        }
+        await model.loadMore()
+        #expect(received?.term == "new")
+        #expect(received?.cursor == "new-cursor")
+    }
+
+    // MARK: - Fetch receipts (the view's paging state)
+
+    @Test func committedFetchReturnsReceipt() async {
+        let frontier = Date(timeIntervalSince1970: 1_760_000_000)
+        let model = makeModel(fetch: { _ in frontier.formatted(.iso8601) })
+        let page = await model.fetch(TestQuery())
+        #expect(page?.nextCursor == frontier.formatted(.iso8601))
+        #expect(page?.frontier == frontier)
+    }
+
+    @Test func exhaustedFetchReturnsReceiptWithoutCursor() async {
+        let model = makeModel(fetch: { _ in nil })
+        let page = await model.fetch(TestQuery())
+        #expect(page != nil)
+        #expect(page?.nextCursor == nil)
+    }
+
+    @Test func failedFetchReturnsNoReceipt() async {
+        let model = makeModel(fetch: { _ in throw LoadError.offline })
+        let page = await model.fetch(TestQuery())
+        #expect(page == nil)
+    }
+
+    // MARK: - retry()
+
+    @Test func retryReRunsLastSearch() async {
+        var received: TestQuery?
+        let model = makeModel(fetch: { query in
+            received = query
+            return nil
+        })
+        await model.fetch(TestQuery(term: "swift", filter: "en"))
+        received = nil
+        await model.retry()
+        #expect(received?.term == "swift")
+        #expect(received?.filter == "en")
+    }
+
+    @Test func retryReRunsAFailedFirstRefresh() async {
+        // The attempted request is remembered even when it fails, so the empty view's
+        // "Try Again" works after a cold-start failure.
+        let model = makeModel(fetch: { _ in throw LoadError.offline })
+        await model.fetch(TestQuery(filter: "en"))
+        #expect(model.state.lastError == .offline)
+
+        var received: TestQuery?
+        model.pipeline = { query in
+            received = query
+            return nil
+        }
+        await model.retry()
+        #expect(received?.filter == "en")
+        #expect(model.state.lastError == nil)
+        #expect(model.state.lastFetched != nil)     // retried refresh records freshness
+    }
+
+    @Test func retryBeforeAnyRequestIsNoOp() async {
+        var callCount = 0
+        let model = makeModel(fetch: { @MainActor _ in
+            callCount += 1
+            return nil
+        })
+        await model.retry()
+        #expect(callCount == 0)
+    }
+
+    // MARK: - Input-less sync feed sugar
+
+    @Test func syncFeedFetches() async {
+        var callCount = 0
+        let model = FeedModel<CatalogueSyncQuery>(label: "catalogue")
+        model.pipeline = { @MainActor _ in
+            callCount += 1
+            return nil
+        }
+        await model.fetch()
+        #expect(callCount == 1)
+        #expect(!model.state.hasMore)     // nil cursor → loadMore never fires
+    }
+}
diff --git a/app-core/Tests/CoreAppTests/FeedSeamTests.swift b/app-core/Tests/CoreAppTests/FeedSeamTests.swift
new file mode 100644
index 00000000..f5f9243b
--- /dev/null
+++ b/app-core/Tests/CoreAppTests/FeedSeamTests.swift
@@ -0,0 +1,118 @@
+import Testing
+import Foundation
+import SwiftData
+import TmbrCore
+import AppApi
+import AppPersistence
+@testable import AppCore
+
+@MainActor
+@Suite("Feed seams")
+struct FeedSeamTests {
+
+    /// `RequestLoader` closures are `@Sendable`; spying on their input needs a main-actor box.
+    @MainActor
+    private final class Box<Value> {
+        var value: Value?
+    }
+
+    private func makeContainer() throws -> ModelContainer {
+        try ModelContainer(
+            for: PostRecord.self, QuoteRecord.self,
+            configurations: ModelConfiguration(isStoredInMemoryOnly: true)
+        )
+    }
+
+    private func stubPost(id: Int) -> PostResponse {
+        PostResponse(
+            id: id,
+            attachment: nil,
+            author: UserResponse(id: 1, appleID: "a", email: nil, firstName: nil, lastName: nil),
+            content: "body",
+            createdAt: Date(timeIntervalSince1970: TimeInterval(id)),
+            language: .en,
+            publishedAt: nil,
+            quotes: [],
+            state: .published,
+            title: "Stub"
+        )
+    }
+
+    /// Builds a model wired the way the `.feed(_:)` modifier does — identity, paging, and the
+    /// fetch pipeline all from the configuration — so the seams are exercised without SwiftUI.
+    private func makeModel(
+        _ configuration: FeedConfiguration<PostsQuery>,
+        context: ModelContext
+    ) -> FeedModel<PostsQuery> {
+        let model = FeedModel<PostsQuery>(label: configuration.label)
+        model.pipeline = configuration.makeFetch(URL(string: "https://test")!, .shared, context)
+        return model
+    }
+
+    // Network seam: an injected configuration with a stub loader never touches the network and
+    // upserts PostRecords through the real store.
+    @Test func networkSeam_stubLoaderUpsertsPostRecords() async throws {
+        let container = try makeContainer()
+        let ctx = container.mainContext
+        let page = PageResult(items: [stubPost(id: 1), stubPost(id: 2)], nextCursor: "more")
+
+        let configuration = FeedConfiguration<PostsQuery>(
+            label: "posts",
+            loader: { _, _ in PostsLoader { _ in page } },
+            upsert: { try PostStore(context: $0).upsert($1.items) },
+            nextCursor: { $0.nextCursor }
+        )
+        let model = makeModel(configuration, context: ctx)
+
+        await model.fetch(PostsQuery())
+
+        #expect(try ctx.fetch(FetchDescriptor<PostRecord>()).count == 2)
+        #expect(model.state.hasMore)
+        #expect(model.state.lastError == nil)
+    }
+
+    // Persistence seam: a spy upserter receives the response loaded via the stub loader, and the
+    // typed input (term, filters) reaches the loader verbatim; load-more threads the cursor via
+    // the descriptor's nextInput while preserving the other fields.
+    @Test func persistenceSeam_spyUpserterReceivesResponse() async throws {
+        let container = try makeContainer()
+        let ctx = container.mainContext
+
+        let sentQuery = Box<PostsQuery>()
+        var received: PageResult<PostResponse>?
+        let configuration = FeedConfiguration<PostsQuery>(
+            label: "posts",
+            loader: { _, _ in
+                PostsLoader { query in
+                    await MainActor.run { sentQuery.value = query }
+                    return PageResult(items: [], nextCursor: query.cursor == nil ? "page-2" : nil)
+                }
+            },
+            upsert: { _, response in received = response },
+            nextCursor: { $0.nextCursor }
+        )
+        let model = makeModel(configuration, context: ctx)
+
+        await model.fetch(PostsQuery(languages: ["en"], term: "swift"))
+        #expect(sentQuery.value?.term == "swift")
+        #expect(sentQuery.value?.cursor == nil)
+        #expect(sentQuery.value?.languages == ["en"])
+        #expect(received != nil)
+
+        await model.loadMore()
+        #expect(sentQuery.value?.cursor == "page-2")
+        #expect(sentQuery.value?.term == "swift")           // session preserved through paging
+        #expect(sentQuery.value?.languages == ["en"])
+
+        #expect(try ctx.fetch(FetchDescriptor<PostRecord>()).isEmpty)  // spy replaced the real upsert
+    }
+
+    // The mapping helpers the tab views use to translate filter selections into API parameters.
+    @Test func filterSetsMapToAPIParameterValues() {
+        #expect(Set<Language>().apiValues == nil)
+        #expect(Set<Language>([.en, .hu]).apiValues == ["en", "hu"])
+        #expect(Set<QuoteSourceFilter>().apiValues == nil)
+        #expect(Set<QuoteSourceFilter>([.blogPosts]).apiValues == ["blog_posts"])
+        #expect(Set<CatalogueCategory>().apiValues == nil)
+    }
+}
diff --git a/app-core/Tests/CoreAppTests/PostUpsertTests.swift b/app-core/Tests/CoreAppTests/PostUpsertTests.swift
index e98a4aa2..2cddd764 100644
--- a/app-core/Tests/CoreAppTests/PostUpsertTests.swift
+++ b/app-core/Tests/CoreAppTests/PostUpsertTests.swift
@@ -2,6 +2,7 @@ import Testing
 import Foundation
 import SwiftData
 import TmbrCore
+import AppPersistence
 @testable import AppCore
 
 @MainActor
@@ -10,12 +11,15 @@ struct PostUpsertTests {
 
     // Hold the container for the test's lifetime — returning a bare `mainContext` lets the container
     // deallocate out from under it (dangling context → trap).
-    private func makeStore() throws -> (PostStore, ModelContext) {
+    private func makeStore() throws -> (PostStore, ModelContainer) {
+        // PostStore.upsert reconciles embedded quotes, so QuoteRecord must be in the schema —
+        // quotes are linked by `postServerID`, not an object relationship, so `for: PostRecord.self`
+        // alone would omit it and trap on the QuoteRecord fetch.
         let container = try ModelContainer(
-            for: PostRecord.self,
+            for: PostRecord.self, QuoteRecord.self,
             configurations: ModelConfiguration(isStoredInMemoryOnly: true)
         )
-        return (PostStore(context: container.mainContext), container.mainContext)
+        return (PostStore(context: container.mainContext), container)
     }
 
     private func post(id: Int, title: String, content: String = "body") -> PostResponse {
@@ -27,6 +31,7 @@ struct PostUpsertTests {
             createdAt: Date(timeIntervalSince1970: TimeInterval(id)),
             language: .en,
             publishedAt: nil,
+            quotes: [],
             state: .published,
             title: title
         )
@@ -37,25 +42,25 @@ struct PostUpsertTests {
     }
 
     @Test func insertsNewPosts() throws {
-        let (store, context) = try makeStore()
+        let (store, container) = try makeStore()
         try store.upsert([post(id: 1, title: "A"), post(id: 2, title: "B")])
-        #expect(try allPosts(context).count == 2)
+        #expect(try allPosts(container.mainContext).count == 2)
     }
 
     @Test func upsertingSameServerIDYieldsOneRecord() throws {
-        let (store, context) = try makeStore()
+        let (store, container) = try makeStore()
         try store.upsert([post(id: 1, title: "A")])
         try store.upsert([post(id: 1, title: "A")])
-        let all = try allPosts(context)
+        let all = try allPosts(container.mainContext)
         #expect(all.count == 1)
         #expect(all.first?.serverID == 1)
     }
 
     @Test func updatesExistingFields() throws {
-        let (store, context) = try makeStore()
+        let (store, container) = try makeStore()
         try store.upsert([post(id: 1, title: "Old", content: "old")])
         try store.upsert([post(id: 1, title: "New", content: "new")])
-        let all = try allPosts(context)
+        let all = try allPosts(container.mainContext)
         #expect(all.count == 1)
         #expect(all.first?.title == "New")
         #expect(all.first?.content == "new")
diff --git a/app-persistence/Sources/AppPersistence/CatalogueCategory.swift b/app-persistence/Sources/AppPersistence/CatalogueCategory.swift
index 1a817c7f..260bd2c6 100644
--- a/app-persistence/Sources/AppPersistence/CatalogueCategory.swift
+++ b/app-persistence/Sources/AppPersistence/CatalogueCategory.swift
@@ -15,4 +15,8 @@ public struct CatalogueCategory: Hashable, Sendable {
     public init(_ record: CatalogueCategoryRecord) {
         self.init(record.slug)
     }
+
+    /// The category's server slug, for API query parameters. Read-only export — the opacity
+    /// guarantee is about *construction* (no smuggling arbitrary strings in), not reading.
+    public var slug: String { rawValue }
 }
diff --git a/tmbr-app/Personal/PersonalApp.swift b/tmbr-app/Personal/PersonalApp.swift
index 3cb6f0e7..fde045a3 100644
--- a/tmbr-app/Personal/PersonalApp.swift
+++ b/tmbr-app/Personal/PersonalApp.swift
@@ -13,7 +13,7 @@ import AppPersistence
 struct PersonalApp: App {
     let container: ModelContainer
     // No-op refresh — Personal's data is CloudKit-mirrored (no fetch). Empty until the write path lands.
-    let blog = BlogModel()
+    // Feeds are no-ops automatically: no `apiBaseURL` in the environment → `@Feed` wires no fetch.
     let catalogue = CatalogueModel()
     let quotes = QuotesModel()
     let preferences = PreferencesModel()
@@ -29,7 +29,6 @@ struct PersonalApp: App {
     var body: some Scene {
         WindowGroup {
             ContentView()
-                .blog(blog)
                 .catalogue(catalogue)
                 .quotes(quotes)
                 .preferences(preferences)
diff --git a/tmbr-app/Reader/CatalogueSync.swift b/tmbr-app/Reader/CatalogueSync.swift
deleted file mode 100644
index 69fc3880..00000000
--- a/tmbr-app/Reader/CatalogueSync.swift
+++ /dev/null
@@ -1,24 +0,0 @@
-import Foundation
-import AppApi
-import AppCore
-import AppPersistence
-import TmbrCore
-
-extension SyncGroup {
-    /// Standard Reader catalogue sync: fetches the six typed lists + orphans + categories from
-    /// `baseURL` and upserts each result into `store`. Runs all in parallel with partial-success
-    /// semantics — individual endpoint failures are logged and surfaced without discarding successes.
-    static func catalogue(baseURL: URL, store: CatalogueStore) -> SyncGroup {
-        let page = PageQuery(limit: 50)
-        return SyncGroup([
-            Syncer("songs",      loader: .songs(baseURL: baseURL),      from: page) { try await store.upsert($0) },
-            Syncer("albums",     loader: .albums(baseURL: baseURL),     from: page) { try await store.upsert($0) },
-            Syncer("books",      loader: .books(baseURL: baseURL),      from: page) { try await store.upsert($0) },
-            Syncer("movies",     loader: .movies(baseURL: baseURL),     from: page) { try await store.upsert($0) },
-            Syncer("podcasts",   loader: .podcasts(baseURL: baseURL),   from: page) { try await store.upsert($0) },
-            Syncer("playlists",  loader: .playlists(baseURL: baseURL),  from: page) { try await store.upsert($0) },
-            Syncer("orphans",    loader: .orphans(baseURL: baseURL),    from: OrphanPageQuery(limit: 50)) { try await store.upsertOrphans($0) },
-            Syncer("categories", loader: .categories(baseURL: baseURL), from: ()) { try await store.replaceCategories($0) },
-        ])
-    }
-}
diff --git a/tmbr-app/Reader/ReaderApp.swift b/tmbr-app/Reader/ReaderApp.swift
index d8d884f1..a4ab3453 100644
--- a/tmbr-app/Reader/ReaderApp.swift
+++ b/tmbr-app/Reader/ReaderApp.swift
@@ -1,20 +1,21 @@
 import SwiftUI
 import SwiftData
-import AppApi
 import AppCore
 import AppPersistence
 
 /// Reader — public, read-only. Plain on-disk SwiftData cache; no auth, no account.
-/// Data enters lazily: the Blog tab's `refresh` fetches public posts + upserts (`ReaderPosts`).
+/// Data enters lazily: feeds (`@Feed`) fetch public posts/quotes/catalogue and upsert; they
+/// compose themselves from `\.apiBaseURL` + the feed descriptors' default pipelines.
 /// The shared UI's seam stays at its defaults: `canAuthor = false`, `accountToolbar = .none`.
 @main
 struct ReaderApp: App {
 
     private let container: ModelContainer
 
-    private let blog: BlogModel
-    private let catalogue: CatalogueModel
+    private let catalogue = CatalogueModel()
+
     private let quotes = QuotesModel()
+
     private let preferences = PreferencesModel()
 
     init() {
@@ -23,35 +24,15 @@ struct ReaderApp: App {
         } catch {
             fatalError("Failed to create Reader ModelContainer: \(error)")
         }
-        let loader = PostsLoader.posts(baseURL: Self.apiBaseURL)
-        let store = PostStore(context: container.mainContext)
-        let posts = ReaderPosts(loader: loader, store: store)
-        let userDefaults = UserDefaults.standard
-        let lastFetchedKey = "reader.blog.lastFetched"
-        blog = BlogModel(
-            refresh: {
-                try await posts.refreshPosts()
-                let now = Date.now
-                userDefaults.set(now, forKey: lastFetchedKey)
-                return now
-            },
-            loadMore: { try await posts.loadMore() },
-            lastFetched: userDefaults.object(forKey: lastFetchedKey) as? Date
-        )
-
-        let catalogueStore = CatalogueStore(context: container.mainContext)
-        let catalogueSync = SyncGroup.catalogue(baseURL: Self.apiBaseURL, store: catalogueStore)
-        catalogue = CatalogueModel(refresh: { try await catalogueSync.run() })
     }
 
     var body: some Scene {
         WindowGroup {
             ContentView()
-                .blog(blog)
                 .catalogue(catalogue)
                 .quotes(quotes)
                 .preferences(preferences)
-                .environment(\.apiBaseURL, Self.apiBaseURL)
+                .environment(\.apiBaseURL, Self.baseURL)
         }
         .modelContainer(container)
 
@@ -63,7 +44,7 @@ struct ReaderApp: App {
         #endif
     }
 
-    private static var apiBaseURL: URL {
+    private static var baseURL: URL {
         guard let raw = Bundle.main.object(forInfoDictionaryKey: "APIBaseURL") as? String,
               !raw.isEmpty, let url = URL(string: raw) else {
             fatalError("APIBaseURL missing or invalid in Info.plist")
diff --git a/tmbr-app/Reader/ReaderPosts.swift b/tmbr-app/Reader/ReaderPosts.swift
deleted file mode 100644
index c39a73ec..00000000
--- a/tmbr-app/Reader/ReaderPosts.swift
+++ /dev/null
@@ -1,69 +0,0 @@
-import Foundation
-import OSLog
-import AppApi
-import AppCore
-import TmbrCore
-import AppPersistence
-
-/// Reader's lazy data-in for the blog: fetch the public posts list (unauthenticated) and upsert
-/// into the local store. `@Query` in `BlogTab` renders the result reactively.
-///
-/// Pagination is cursor-based: `refreshPosts()` loads the first page and stores a `nextCursor`
-/// (if the server returned one); `loadMore()` continues from that cursor. `nextCursor` is reset
-/// on every full refresh so pull-to-refresh always starts clean.
-///
-@MainActor
-final class ReaderPosts {
-
-    private let loader: PostsLoader
-
-    private let store: PostStore
-
-    private let logger = Logger(subsystem: "me.tmbr", category: "sync")
-
-    private var nextCursor: String?
-
-    init(loader: PostsLoader, store: PostStore) {
-        self.loader = loader
-        self.store = store
-    }
-
-    // MARK: - Refresh (first page)
-
-    /// Fetches the first page and upserts it. Resets the cursor so subsequent `loadMore()` calls
-    /// continue from the right position.
-    func refreshPosts() async throws {
-        let page = try await fetch(cursor: nil)
-        nextCursor = page.nextCursor
-        try store.upsert(page.items)
-        logger.info("Blog refresh: loaded \(page.items.count) posts, nextCursor=\(page.nextCursor ?? "nil")")
-    }
-
-    // MARK: - Load more (subsequent pages)
-
-    /// Fetches the next cursor page and upserts it. Returns `true` if more pages remain.
-    /// Returns `false` immediately (without a network call) when there is no cursor.
-    func loadMore() async throws -> Bool {
-        guard let cursor = nextCursor else { return false }
-        let page = try await fetch(cursor: cursor)
-        nextCursor = page.nextCursor
-        try store.upsert(page.items)
-        logger.info("Blog load-more: loaded \(page.items.count) posts, nextCursor=\(page.nextCursor ?? "nil")")
-        return page.nextCursor != nil
-    }
-
-    // MARK: - Private
-
-    private func fetch(cursor: String?) async throws -> PageResult<PostResponse> {
-        let query = PageQuery(cursor: cursor, limit: 50)
-        do {
-            return try await loader.load(from: query)
-        } catch let error as RequestError {
-            logger.error("Blog fetch failed with HTTP error: \(error)")
-            throw LoadError.server(status: {
-                if case .httpError(let status, _) = error { return status }
-                return nil
-            }())
-        }
-    }
-}
diff --git a/tmbr-app/tmbr-app.xcodeproj/project.pbxproj b/tmbr-app/tmbr-app.xcodeproj/project.pbxproj
index c5576ee2..4981df80 100644
--- a/tmbr-app/tmbr-app.xcodeproj/project.pbxproj
+++ b/tmbr-app/tmbr-app.xcodeproj/project.pbxproj
@@ -10,11 +10,11 @@
 		03297F0053BB73A1328B6378 /* AppCore in Frameworks */ = {isa = PBXBuildFile; productRef = 8229BF76A2BB18E12999E69F /* AppCore */; };
 		109CB8C24233693E8E8EF54C /* TmbrCore in Frameworks */ = {isa = PBXBuildFile; productRef = F193199EDBC5D787AC73097C /* TmbrCore */; };
 		2549866CD08843ECFBA90108 /* TmbrCore in Frameworks */ = {isa = PBXBuildFile; productRef = D47E8BCA7C0DA4C5D5F9513D /* TmbrCore */; };
-		AA000004BB000004CC000004 /* AppPersistence in Frameworks */ = {isa = PBXBuildFile; productRef = AA000002BB000002CC000002 /* AppPersistence */; };
-		AA000005BB000005CC000005 /* AppPersistence in Frameworks */ = {isa = PBXBuildFile; productRef = AA000003BB000003CC000003 /* AppPersistence */; };
 		707239A243CF738549160865 /* Cocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = E173FBA3F6594B28E84BDB5C /* Cocoa.framework */; };
 		9692272AC826634604D10C7E /* AppCore in Frameworks */ = {isa = PBXBuildFile; productRef = 4359256FA09B2AD131BFF498 /* AppCore */; };
 		A838BCBD3A5F97E873E1C206 /* AppApi in Frameworks */ = {isa = PBXBuildFile; productRef = CD234EC0DAF2EA0B8DE0C637 /* AppApi */; };
+		AA000004BB000004CC000004 /* AppPersistence in Frameworks */ = {isa = PBXBuildFile; productRef = AA000002BB000002CC000002 /* AppPersistence */; };
+		AA000005BB000005CC000005 /* AppPersistence in Frameworks */ = {isa = PBXBuildFile; productRef = AA000003BB000003CC000003 /* AppPersistence */; };
 		E2497B602FE1302F00D1B325 /* AppCore in Frameworks */ = {isa = PBXBuildFile; productRef = E2497B5F2FE1302F00D1B325 /* AppCore */; };
 		E27B48712FC58690006866D7 /* TmbrCore in Frameworks */ = {isa = PBXBuildFile; productRef = E27B48722FC58690006866D7 /* TmbrCore */; };
 		E27C0B542FC5FE480055C952 /* AppApi in Frameworks */ = {isa = PBXBuildFile; productRef = E27C0B532FC5FE480055C952 /* AppApi */; };
@@ -1074,6 +1074,10 @@
 /* End XCConfigurationList section */
 
 /* Begin XCLocalSwiftPackageReference section */
+		AA000001BB000001CC000001 /* XCLocalSwiftPackageReference "../app-persistence" */ = {
+			isa = XCLocalSwiftPackageReference;
+			relativePath = "../app-persistence";
+		};
 		E2497BB72FE13F5400D1B325 /* XCLocalSwiftPackageReference "../app-core" */ = {
 			isa = XCLocalSwiftPackageReference;
 			relativePath = "../app-core";
@@ -1086,10 +1090,6 @@
 			isa = XCLocalSwiftPackageReference;
 			relativePath = "../app-api";
 		};
-		AA000001BB000001CC000001 /* XCLocalSwiftPackageReference "../app-persistence" */ = {
-			isa = XCLocalSwiftPackageReference;
-			relativePath = "../app-persistence";
-		};
 /* End XCLocalSwiftPackageReference section */
 
 /* Begin XCSwiftPackageProductDependency section */
@@ -1103,6 +1103,16 @@
 			package = E2497BB72FE13F5400D1B325 /* XCLocalSwiftPackageReference "../app-core" */;
 			productName = AppCore;
 		};
+		AA000002BB000002CC000002 /* AppPersistence */ = {
+			isa = XCSwiftPackageProductDependency;
+			package = AA000001BB000001CC000001 /* XCLocalSwiftPackageReference "../app-persistence" */;
+			productName = AppPersistence;
+		};
+		AA000003BB000003CC000003 /* AppPersistence */ = {
+			isa = XCSwiftPackageProductDependency;
+			package = AA000001BB000001CC000001 /* XCLocalSwiftPackageReference "../app-persistence" */;
+			productName = AppPersistence;
+		};
 		CD234EC0DAF2EA0B8DE0C637 /* AppApi */ = {
 			isa = XCSwiftPackageProductDependency;
 			package = E27C0B512FC5FE100055C952 /* XCLocalSwiftPackageReference "../app-api" */;
@@ -1133,16 +1143,6 @@
 			package = E27B48702FC58689006866D7 /* XCLocalSwiftPackageReference "../tmbr-core" */;
 			productName = TmbrCore;
 		};
-		AA000002BB000002CC000002 /* AppPersistence */ = {
-			isa = XCSwiftPackageProductDependency;
-			package = AA000001BB000001CC000001 /* XCLocalSwiftPackageReference "../app-persistence" */;
-			productName = AppPersistence;
-		};
-		AA000003BB000003CC000003 /* AppPersistence */ = {
-			isa = XCSwiftPackageProductDependency;
-			package = AA000001BB000001CC000001 /* XCLocalSwiftPackageReference "../app-persistence" */;
-			productName = AppPersistence;
-		};
 /* End XCSwiftPackageProductDependency section */
 	};
 	rootObject = E27B47802FC4E864006866D7 /* Project object */;
diff --git a/tmbr-app/tmbr/RootView.swift b/tmbr-app/tmbr/RootView.swift
index ea2153cc..701c5435 100644
--- a/tmbr-app/tmbr/RootView.swift
+++ b/tmbr-app/tmbr/RootView.swift
@@ -6,13 +6,12 @@ import AppCore
 struct RootView: View {
     @Environment(AuthState.self) private var authState
     // No-op refresh for now — Author's blog/catalogue data-in is its SyncEngine (later stage).
-    @State private var blog = BlogModel()
+    // Feeds are no-ops automatically: no `apiBaseURL` in the environment → `@Feed` wires no fetch.
     @State private var catalogue = CatalogueModel()
     @State private var quotes = QuotesModel()
 
     var body: some View {
         ContentView()
-            .blog(blog)
             .catalogue(catalogue)
             .quotes(quotes)
             .environment(\.canAuthor, authState.isSignedIn)
diff --git a/tmbr-core/Sources/TmbrCore/Pagination/PostsQuery.swift b/tmbr-core/Sources/TmbrCore/Pagination/PostsQuery.swift
index 0846a18e..ddaa6a3f 100644
--- a/tmbr-core/Sources/TmbrCore/Pagination/PostsQuery.swift
+++ b/tmbr-core/Sources/TmbrCore/Pagination/PostsQuery.swift
@@ -2,31 +2,63 @@ import Foundation
 
 /// Query parameters for `GET /api/posts` — supports both paginated browse and text search.
 ///
-/// The server accepts `term`, `since`, `cursor`, and `limit` in any combination.
+/// The server accepts `term`, `since`, `cursor`, `limit`, and `languages` in any combination.
 /// Pass `term` to filter results by text; omit it for a plain paginated list.
-public struct PostsQuery: Codable, Sendable {
-
-    /// Optional full-text filter. `nil` means browse all posts.
-    public let term: String?
-
-    /// Delta-sync cursor — returns items created after this date.
-    public let since: Date?
+public struct PostsQuery: Codable, Hashable, Sendable {
 
     /// Load-more cursor — opaque value from the previous `PageResult.nextCursor`.
     public let cursor: String?
 
+    /// Language codes to filter by. `nil` means the server's language preference applies.
+    public let languages: [String]?
+    
     /// Maximum items per page (server default: 50, server max: 100).
     public let limit: Int
+    
+    /// Delta-sync cursor — returns items created after this date.
+    public let since: Date?
+    
+    /// Optional full-text filter. `nil` means browse all posts.
+    public let term: String?
 
     public init(
-        term: String? = nil,
-        since: Date? = nil,
         cursor: String? = nil,
-        limit: Int = 50
+        languages: [String]? = nil,
+        limit: Int = 50,
+        since: Date? = nil,
+        term: String? = nil
     ) {
         self.term = term
         self.since = since
         self.cursor = cursor
         self.limit = limit
+        self.languages = languages
+    }
+    
+    public init(
+        cursor: String? = nil,
+        languages: Set<Language>? = nil,
+        limit: Int = 50,
+        since: Date? = nil,
+        term: String
+    ) {
+        self.init(
+            cursor: cursor,
+            languages: languages?.map { $0.rawValue },
+            limit: limit,
+            since: since,
+            term: term.isEmpty ? nil : term
+        )
+    }
+
+    /// The same query pointed at the next page — `cursor` replaced, everything else preserved.
+    public func page(after cursor: String) -> Self {
+        PostsQuery(
+            cursor: cursor,
+            languages: languages,
+            limit: limit,
+            since: since,
+            term: term
+        )
     }
 }
diff --git a/tmbr-core/Sources/TmbrCore/Pagination/QuotesQuery.swift b/tmbr-core/Sources/TmbrCore/Pagination/QuotesQuery.swift
index ca9e9a02..78769db4 100644
--- a/tmbr-core/Sources/TmbrCore/Pagination/QuotesQuery.swift
+++ b/tmbr-core/Sources/TmbrCore/Pagination/QuotesQuery.swift
@@ -3,24 +3,62 @@ import Foundation
 /// Query parameters for `GET /api/catalogue/quotes` — supports both paginated browse and text search.
 ///
 /// Pass `term` to filter results by text; omit it for a plain paginated list.
-public struct QuotesQuery: Codable, Sendable {
-
-    /// Optional full-text filter. `nil` means browse all quotes.
-    public let term: String?
+public struct QuotesQuery: Codable, Hashable, Sendable {
 
     /// Load-more cursor — opaque value from the previous `PageResult.nextCursor`.
     public let cursor: String?
 
+    /// Language codes to filter by. `nil` means the server's language preference applies.
+    public let languages: [String]?
+
     /// Maximum items per page (server default: 50, server max: 100).
     public let limit: Int
 
+    /// Source buckets to filter by: catalogue category slugs plus the `blog_posts` sentinel.
+    /// `nil` means all sources.
+    public let sources: [String]?
+
+    /// Optional full-text filter. `nil` means browse all quotes.
+    public let term: String?
+
     public init(
-        term: String? = nil,
         cursor: String? = nil,
-        limit: Int = 50
+        languages: [String]? = nil,
+        limit: Int = 50,
+        sources: [String]? = nil,
+        term: String? = nil
     ) {
-        self.term = term
         self.cursor = cursor
+        self.languages = languages
         self.limit = limit
+        self.sources = sources
+        self.term = term
+    }
+
+    public init(
+        cursor: String? = nil,
+        languages: Set<Language>? = nil,
+        limit: Int = 50,
+        sources: [String]? = nil,
+        term: String
+    ) {
+        self.init(
+            cursor: cursor,
+            languages: languages?.map { $0.rawValue },
+            limit: limit,
+            sources: sources,
+            term: term.isEmpty ? nil : term
+        )
+    }
+
+    /// The same query pointed at the next page — `cursor` replaced, everything else preserved.
+    public func page(after cursor: String) -> Self {
+        QuotesQuery(
+            cursor: cursor,
+            languages: languages,
+            limit: limit,
+            sources: sources,
+            term: term
+        )
     }
 }
diff --git a/tmbr-core/Sources/TmbrCore/Search/CatalogueSearchQuery.swift b/tmbr-core/Sources/TmbrCore/Search/CatalogueSearchQuery.swift
index 631c41dd..df69a5a4 100644
--- a/tmbr-core/Sources/TmbrCore/Search/CatalogueSearchQuery.swift
+++ b/tmbr-core/Sources/TmbrCore/Search/CatalogueSearchQuery.swift
@@ -7,7 +7,7 @@ import Foundation
 ///
 /// `cursor` is an ISO 8601 date string returned as `nextCursor` from a previous response;
 /// the server treats it as "return only items created before this date".
-public struct CatalogueSearchQuery: Codable, Sendable {
+public struct CatalogueSearchQuery: Codable, Hashable, Sendable {
 
     public let term: String
 
@@ -33,4 +33,9 @@ public struct CatalogueSearchQuery: Codable, Sendable {
         self.cursor = cursor
         self.limit = limit
     }
+
+    /// The same query pointed at the next page — `cursor` replaced, everything else preserved.
+    public func page(after cursor: String) -> Self {
+        CatalogueSearchQuery(term: term, types: types, languages: languages, cursor: cursor, limit: limit)
+    }
 }