? _page; protected override async Task OnInitializedAsync() { _page = await Resolver.GetPagedAsync(Page ?? 1, pageSize: 20); } private static string PageUrl(int page) => page <= 1 ? "/articles" : $"/articles/page/{page}/"; } ``` `ArticleResolver` collects the markdown articles from every content source and slices them into pages. It is a plain service — not an `IContentService` — so it can inject `IEnumerable` directly with no risk of a cycle. ```csharp:symbol namespace PaginatedListingExample; using Pennington.Content; using Pennington.Pipeline; ///

One entry in the article listing.

/// Canonical URL of the article. /// Display title. public sealed record Article(string Url, string Title); ///

/// Collects the markdown articles under /articles/ from every registered /// and serves them one page at a time. Injected by the /// ArticlesPage Razor component. It is not registered as an , /// so the plain injection here is safe — only the discovery service /// (which is in that set) has to resolve siblings lazily to avoid a cycle. ///

public sealed class ArticleResolver(IEnumerable services) { ///

Returns the requested 1-based page of articles, ordered by URL.

public async Task> GetPagedAsync(int page, int pageSize) { var all = await CollectAsync(); var skip = Math.Max(0, (page - 1) * pageSize); var items = all.Skip(skip).Take(pageSize).ToList(); return new PagedList

(items, page, pageSize, all.Count); } private async Task> CollectAsync() { var articles = new List

(); await foreach (var item in services.DiscoverAllAsync()) { if (item.Source.Value is FileSource { IsMarkdown: true } && item.Route.CanonicalPath.Value.StartsWith("/articles/")) { var url = item.Route.CanonicalPath.Value; articles.Add(new Article(url, item.Metadata?.Title ?? url)); } } return articles.OrderBy(a => a.Url, StringComparer.Ordinal).ToList(); } } ``` ### The content service A parameterized `@page` template (`{Page:int}`) is skipped by Pennington's automatic Razor route discovery. Emit each paginated route explicitly so the static build crawls them. The service is itself one of the registered `IContentService` instances, so it must **not** constructor-inject `IEnumerable` — that forms a dependency cycle and throws at startup. Inject `IServiceProvider` instead and resolve the siblings on demand inside `DiscoverAsync`, excluding self with `!ReferenceEquals(s, this)`. This is the same pattern the library's own `SocialCardContentService` uses. ```csharp:symbol public sealed class ArticleListingContentService(IServiceProvider serviceProvider) : IContentService, IMetaContentService { private const int PageSize = 20; /// public string DefaultSectionLabel => ""; /// public int SearchPriority => 0; /// public async IAsyncEnumerable DiscoverAsync() { // Resolve siblings on demand rather than via a ctor IEnumerable: this // service is itself in that set, so the ctor injection would be a DI cycle. Filter out every // meta-service (this one included) so the sibling walk can't recurse back into this discovery // — reference-equality self-exclusion would miss the fresh transient copies GetServices hands back. var siblings = serviceProvider.GetServices() .SourceServices() .ToList(); var count = 0; await foreach (var item in siblings.DiscoverAllAsync()) { if (item.Source.Value is FileSource { IsMarkdown: true } && item.Route.CanonicalPath.Value.StartsWith("/articles/")) { count++; } } ContentSource source = new RazorPageSource(typeof(ArticlesPage).AssemblyQualifiedName!); var totalPages = (int)Math.Ceiling(count / (double)PageSize); for (var page = 2; page <= totalPages; page++) { yield return new DiscoveredItem( new ContentRoute { CanonicalPath = new UrlPath($"/articles/page/{page}/"), OutputFile = new FilePath($"articles/page/{page}/index.html"), }, source); } } /// public Task> GetContentToCopyAsync() => Task.FromResult(ImmutableList.Empty); /// public Task> GetContentTocEntriesAsync() => Task.FromResult(ImmutableList.Empty); /// public Task> GetCrossReferencesAsync() => Task.FromResult(ImmutableList.Empty); } ``` Register the resolver and the service alongside the markdown source. `ArticleResolver` is a plain transient; `ArticleListingContentService` joins the `IContentService` set the same way any markdown source does. ```csharp builder.Services.AddTransient(); builder.Services.AddTransient(); ``` ## What ends up where - **Sitemap.** Paginated routes appear in `sitemap.xml` automatically — they come from `DiscoverAsync` as HTML routes and `SitemapService` includes everything that isn't a redirect or llms-only sidecar. - **Search index and llms.txt.** Excluded by default: `BlogSiteContentService` and the custom service above return empty `GetIndexableEntriesAsync()` (the default forwards to `GetContentTocEntriesAsync()`), so their routes never enter the search or llms paths. If a custom service does emit indexable entries for paginated routes, set `ExcludeFromSearch = true` and `ExcludeFromLlms = true` on those entries. - **Navigation tree.** Same — paginated routes have no TOC entry, so they don't show in the sidebar or breadcrumbs. ## Verify - Run `dotnet run` and visit `/articles`. The first 20 articles render, with the `Pagination` controls below them. - Visit `/articles/page/2/`. The remaining articles render and the control highlights page 2 — confirming `ArticleListingContentService.DiscoverAsync` emitted the overflow route. - Run `dotnet run -- build` and open `sitemap.xml` in the output directory. It lists `/articles/page/2/` alongside the individual article URLs, because the route flows through `DiscoverAsync` as an HTML route. ## Related - Reference: [BlogSiteOptions.PostsPerPage](https://usepennington.net/reference/api/blog-site-options.md) - Background: [Content pipeline overview](https://usepennington.net/explanation/core/content-pipeline.md) - Extensibility: [Source content from outside the file system](https://usepennington.net/how-to/content-services/custom-content-service.md) [Previous Serve the site in multiple languages](https://usepennington.net/how-to/discovery/localization.md)[Next Flag missing and outdated translations in the build report and dev overlay](https://usepennington.net/how-to/discovery/audit-translations.md)