@geekity/cms 0.30.0 → 0.31.0

package/dist/web/routes.js

@@ -1,42 +1,39 @@
-import { listUsers } from '../admin/accounts.js';
-import { readSiteSettings, robotsPolicyOf } from '../admin/settings.js';
-import { postLabel } from '../content/post-type.js';
-import { serializeDocument } from '../content/writer.js';
-import { mountAvatars } from '../avatars/routes.js';
-import { readAltTexts } from '../images/alt-text.js';
-import { FAVICON_FILE, iconSetting, siteIconSource } from '../images/icons.js';
-import { sourceVersion } from '../images/paths.js';
-import { findImageVariant, VARIANT_ASSET_PREFIX } from '../images/variants.js';
-import { ASSET_VERSION_PARAM, assetNotModified, assetRangeResponse, assetResponse, assetVersion, findThemeAsset, findUpload, IMMUTABLE_ASSET, matchesEtag, THEME_ASSET_PREFIX, UPLOAD_ASSET_MAX_AGE, UPLOAD_ASSET_PREFIX, } from './assets.js';
-import { COMMENT_NOTICE_PARAM, COMMENT_REPLY_PARAM } from '../comments/form.js';
-import { answerable, commentPolicyOf } from '../comments/policy.js';
-import { commentNoticeFor, commentReplyTarget, mountComments } from '../comments/routes.js';
-import { commenterOf } from '../comments/viewer.js';
-import { CONTACT_NOTICE_PARAM, contactNoticeFor } from '../contact/form.js';
-import { mountContact } from '../contact/routes.js';
-import { mountPingbacks, pingbackEndpointFor } from '../webmention/pingback.js';
-import { mountWebmentions, WEBMENTION_PATH } from '../webmention/routes.js';
-import { mountNotificationLinks } from '../notifications/routes.js';
-import { advertiseIdentityEndpoints } from '../indieauth/discovery.js';
-import { publicAdminBar } from './admin-bar.js';
-import { authorFeedHref, authorContext, authorHref, authorNames, parseAuthorPath, profileContext, siteAuthorContext, } from './authors.js';
-import { feedComments, spokenIn } from './conversation.js';
-import { COMMENT_PAGE_PREFIX } from './guids.js';
-import { goneDocumentAt, isGone, isListed, isServed, permalinkOfObjectId, previewDocumentAt, publicDocumentAt, } from './documents.js';
-import { commentsFeedPath, REPLIES_ROOT, repliesFeedPath, commentsFeedResponse, feedPathUnder, feedResponse, feedSize, splitFeedPath, COMMENTS_ROOT, COMMENTS_TITLE_PREFIX, FEED_FORMATS, FEED_SEGMENTS, } from './feeds.js';
-import { absoluteUrl, DOCUMENT_REPRESENTATIONS, documentJson, LISTING_REPRESENTATIONS, SEARCH_REPRESENTATIONS, lastModifiedOf, latestModified, MEDIA_TYPES, notAcceptableResponse, representationHref, representationEtag, representationResponse, selectRepresentation, splitRepresentationExtension, } from './negotiate.js';
-import { offsetForPage, paginate } from './pagination.js';
-import { TEMPLATES } from './render.js';
-import { robotsResponse, ROBOTS_PATH } from './robots.js';
-import { sitemapResponse, SITEMAP_CHILD_ROUTE, SITEMAP_PATH } from './sitemap.js';
+import { mountAvatars } from './avatar-routes.js';
+import { mountComments } from './comment-routes.js';
+import { mountContact } from './contact-routes.js';
+import { COMMENT_PAGE_PREFIX } from '../content/guids.js';
+import { findPathRedirect, findQueryRedirect, redirectLocation } from '../content/redirects.js';
+import { UPLOAD_ASSET_PREFIX, VARIANT_ASSET_PREFIX } from '../content/uploads.js';
+import { iconSetting } from '../images/icons.js';
+import { advertiseIdentityEndpoints } from './indieauth-discovery.js';
+import { mountNotificationLinks } from './notification-routes.js';
+import { robotsPolicyOf } from '../site/settings.js';
+import { readSiteSettings } from '../site/site-json.js';
+import { mountPingbacks } from './pingback-routes.js';
+import { mountWebmentions } from './webmention-routes.js';
+import { favicon, imageVariant, themeAsset, upload } from './asset-routes.js';
+import { THEME_ASSET_PREFIX } from '../theme/assets.js';
+import { negotiateDocument } from './document-page.js';
+import { goneDocumentAt, previewDocumentAt } from '../content/permalinks.js';
+import { embedView, oEmbed } from './embed.js';
+import { commentPage, comments, feed, repliesFeed } from './feed-routes.js';
+import { feedPathUnder, FEED_FORMATS, REPLIES_ROOT, splitFeedPath } from './feeds.js';
+import { indexNowKeyPath, indexNowKeyResponse } from '../site/indexnow-key.js';
+import { listing, search } from './listing-pages.js';
+import { feedHref, SITE_POSTS } from './listing-subject.js';
+import { LLMS_TXT_LINK, LLMS_TXT_PATH } from './llms.js';
 import { FAVICON_PATH, manifestResponse, MANIFEST_PATH, webManifest } from './manifest.js';
+import { DOCUMENT_REPRESENTATIONS, LISTING_REPRESENTATIONS, representationHref, SEARCH_REPRESENTATIONS, splitRepresentationExtension, } from './negotiate.js';
+import { EMBED_PATH, OEMBED_PATH } from './oembed.js';
 import { openSearchDescription, openSearchResponse, OPENSEARCH_PATH } from './opensearch.js';
-import { EMBED_PATH, embedPage, embedResponse, OEMBED_PATH, oEmbedFor, oEmbedRequest, oEmbedResponse, } from './oembed.js';
-import { generatedLlmsTxt, llmsListingTxt, LLMS_TXT_LINK, LLMS_TXT_PATH, llmsTxtResponse, ownLlmsTxt, } from './llms.js';
-import { indexNowKeyPath, indexNowKeyResponse } from './indexnow.js';
-import { searchHref, searchJson, searchPageIndex, searchQuery, SEARCH_PAGE_PARAM, SEARCH_PATH, SEARCH_QUERY_PARAM, } from './search.js';
-import { findPathRedirect, findQueryRedirect, redirectLocation } from './redirects.js';
-import { PAGE_SEGMENT, redirectedTerm, taxonomyForSegment, termHref } from './taxonomy.js';
+import { canonicalHref, classifyPath, commentsFeedHref, movedHref, parseTermPath, slashedHref, } from './paths.js';
+import { conditionalHeaders, encodePath, gone, notFound, queryFeedFormat, requestPath, requestSearch, selectFromAccept, } from './request.js';
+import { robotsResponse, ROBOTS_PATH } from './robots.js';
+import { SEARCH_PATH } from './search.js';
+import { llmsTxt, sitemap } from './site-index.js';
+import { siteView } from './site-view.js';
+import { SITEMAP_CHILD_ROUTE, SITEMAP_PATH } from './sitemap.js';
+import { redirectedTerm, termHref } from '../content/taxonomy.js';
 /**
  * Register the public site on a Hono app.
  *
@@ -45,10 +42,9 @@ import { PAGE_SEGMENT, redirectedTerm, taxonomyForSegment, termHref } from './ta
  * routes registered after this one still win, and a permalink can never shadow
  * them, because the document lookup only runs once nothing else has matched.
  */
-export function mountPublicSite(app) {
-    // First, so every page below it, the 404 and the 500 included, is drawn
-    // knowing whether a signed-in user is reading it (TASK-183).
-    app.use('*', publicAdminBar);
+export function mountPublicSite(app, { adminBar } = {}) {
+    if (adminBar !== undefined)
+        app.use('*', adminBar);
     app.use('*', advertiseIdentityEndpoints);
     app.use('*', declaredQueryRedirect);
     app.get(`${THEME_ASSET_PREFIX}*`, themeAsset);
@@ -79,10 +75,10 @@ export function mountPublicSite(app) {
         // whole of WordPress's "Your homepage displays", decided per request off
         // `site.json` so a save on the settings screen moves the front page on the
         // very next one.
-        const home = frontPages(c).home;
+        const home = siteView(c).pages.home;
         const response = home === undefined
-            ? listing(c, { term: undefined, pageNumber: 0 })
-            : negotiateDocument(c, home, selectFromAccept(c, DOCUMENT_REPRESENTATIONS), '/');
+            ? listing(c, { subject: SITE_POSTS, pageNumber: 0 })
+            : negotiateDocument(c, home, selectFromAccept(c, DOCUMENT_REPRESENTATIONS));
         // The home page is where a tool that found the site looks for its index
         // (TASK-149): a header, so it is found without parsing the page.
         if (readSiteSettings(c.var.config.contentDir).llmsTxt) {
@@ -90,29 +86,13 @@ export function mountPublicSite(app) {
         }
         return response;
     });
-    app.get(`/${PAGE_SEGMENT}/:page{[0-9]+}/`, (c) => {
-        const requested = Number(c.req.param('page'));
-        // Page one is the home page; it does not get a second URL.
-        if (requested <= 1)
-            return c.redirect('/', 301);
-        const pages = frontPages(c);
-        // With a posts page, the listing's pages live under it and these are the
-        // URLs they used to have; with a static homepage and no posts page, the
-        // listing has no page of its own and neither have its pages.
-        if (pages.posts !== undefined) {
-            return c.redirect(listingPageHref(pages.posts.permalink, requested - 1), 301);
-        }
-        if (pages.home !== undefined)
-            return notFound(c);
-        return listing(c, { term: undefined, pageNumber: requested - 1 });
-    });
     // The site's own feeds are routes rather than representations, so a reader's
     // careless `Accept` header cannot land it on the HTML (doc-3), and so a
     // document permalinked at `/feed/` cannot take the subscribers' URL. Their
     // paths are fixed — only the taxonomy feeds hang off a configurable base —
     // so the route table can hold them.
     for (const format of FEED_FORMATS) {
-        app.get(feedPathUnder('/', format), (c) => feed(c, format, {}));
+        app.get(feedPathUnder('/', format), (c) => feed(c, format, SITE_POSTS));
     }
     // The site-wide comments feed, for the same reason and at WordPress's URL.
     app.get(commentsFeedHref(undefined), (c) => comments(c, undefined));
@@ -153,15 +133,8 @@ export function mountPublicSite(app) {
     // same prefix: the one response another site may put in a frame.
     app.get(EMBED_PATH, embedView);
     // The index for language models (TASK-149), a fixed path at the root for
-    // the same reason. Off is a 404; a file of the site's own wins over the
-    // generated one.
-    app.get(LLMS_TXT_PATH, (c) => {
-        const { contentDir, baseUrl } = c.var.config;
-        if (!readSiteSettings(contentDir).llmsTxt)
-            return notFound(c);
-        const file = ownLlmsTxt(contentDir) ?? generatedLlmsTxt(llmsIndex(c), baseUrl);
-        return llmsTxtResponse(file, conditionalHeaders(c));
-    });
+    // the same reason.
+    app.get(LLMS_TXT_PATH, llmsTxt);
     // The IndexNow key file (TASK-151), at the root because that is where an
     // engine checks for it. Any other `.txt` path is not this route's: it falls
     // through to whatever document or 404 would have answered it.
@@ -182,73 +155,13 @@ export function mountPublicSite(app) {
     // the way to the real one.
     app.get(SEARCH_PATH, (c) => search(c, selectFromAccept(c, SEARCH_REPRESENTATIONS)));
     app.get(representationHref(SEARCH_PATH, 'json'), (c) => search(c, 'json'));
-    app.get(SEARCH_PATH.slice(0, -1), (c) => c.redirect(`${SEARCH_PATH}${new URL(c.req.url).search}`, 301));
-    // The taxonomy archives are deliberately not routes. A route table is fixed
-    // when the app is built and the bases are a setting, so an archive is
-    // resolved per request in the not-found handler, from the base the site
-    // holds at that moment (TASK-36).
+    app.get(SEARCH_PATH.slice(0, -1), (c) => c.redirect(`${SEARCH_PATH}${requestSearch(c)}`, 301));
+    // The archives and the home listing's pages are deliberately not routes. A
+    // route table is fixed when the app is built, and the bases and the posts
+    // page are settings, so a listing is resolved per request in the not-found
+    // handler, from what the site holds at that moment (TASK-36).
     app.notFound(resolveRequest);
 }
-/**
- * The oEmbed of the post or page a URL names, a 404 when it names none, and a
- * 501 for a format the spec allows and this provider does not serve.
- */
-function oEmbed(c) {
-    const request = oEmbedRequest((name) => c.req.query(name));
-    const found = embeddableAt(c, request.url);
-    if (found === undefined)
-        return notFound(c);
-    if (request.format === undefined)
-        return c.text('Not Implemented', 501);
-    const embed = oEmbedFor({ ...embedSubject(c, found), config: c.var.config, request });
-    return oEmbedResponse(embed, request.format, conditionalHeaders(c));
-}
-/**
- * The card of the post or page a URL names as a page another site may frame,
- * and a 404, framed by nobody else, when it names none.
- */
-function embedView(c) {
-    const found = embeddableAt(c, c.req.query('url') ?? '');
-    if (found === undefined)
-        return notFound(c);
-    c.set('frameable', true);
-    return embedResponse(embedPage(embedSubject(c, found)), conditionalHeaders(c));
-}
-/** What an embed of `found` is drawn from, with the byline it names. */
-function embedSubject(c, found) {
-    const site = c.var.renderer.site();
-    const users = listUsers(c.var.config.dataDir);
-    return {
-        ...found,
-        label: postLabel(found.document, (url) => c.var.replyContexts.read(url)),
-        // Who the byline names: the document's author, else the site's.
-        author: authorContext(users, found.document.author) ?? siteAuthorContext(users, site.author),
-        config: c.var.config,
-        site,
-    };
-}
-/**
- * The published post or page an absolute URL is the page of, and where it is
- * served, or `undefined`.
- *
- * The same lookup a request for that URL makes, so an embed exists exactly
- * where a page does: a URL on this site's origin and under its base path,
- * with no query, at a public document's permalink. `/` is the static
- * homepage when there is one, and the posts page is the listing it carries
- * rather than a page to embed.
- */
-function embeddableAt(c, url) {
-    const pathname = permalinkOfObjectId(url, c.var.config.baseUrl);
-    if (pathname === undefined)
-        return undefined;
-    const pages = frontPages(c);
-    if (pathname === '/')
-        return pages.home === undefined ? undefined : { document: pages.home, href: '/' };
-    const document = publicDocumentAt(c.var.store, pathname);
-    if (document === undefined || document.path === pages.posts?.path)
-        return undefined;
-    return { document, href: document.path === pages.home?.path ? '/' : document.permalink };
-}
 /**
  * A declared redirect whose source names a query, WordPress's `/?p=123` above
  * all (TASK-128). It is answered before any route because `/` is one the
@@ -257,7 +170,7 @@ function embeddableAt(c, url) {
  */
 const declaredQueryRedirect = async (c, next) => {
     if (c.req.method === 'GET' || c.req.method === 'HEAD') {
-        const { search } = new URL(c.req.url);
+        const search = requestSearch(c);
         const redirect = search === ''
             ? undefined
             : findQueryRedirect(c.var.redirects.current(), requestPath(c), search);
@@ -266,132 +179,56 @@ const declaredQueryRedirect = async (c, next) => {
     }
     await next();
 };
-/**
- * The last stop for a request: a taxonomy archive or one of its feeds, the
- * document at this URL, the same document in the representation a `.md` or
- * `.json` suffix asked for, the canonical URL it should have asked for, or the
- * theme's 404.
- *
- * The archives come first, so an archive URL means the archive however a
- * document is permalinked; they are here rather than in the route table
- * because their bases are a setting, and a route table is fixed when the app
- * is built. The suffix is stripped and the *same* {@link publicDocumentAt}
- * lookup runs again, so no representation can resolve to a document the others
- * cannot see.
- */
 function resolveRequest(c) {
-    const { store, renderer } = c.var;
+    const view = siteView(c);
     const pathname = requestPath(c);
-    const bases = renderer.taxonomyBases();
-    const authors = authorsOf(c);
-    const pages = frontPages(c);
-    // The posts page carries the listing at its own URL, so it is answered
-    // before the document lookup that would otherwise render it as the page it
-    // also is. Its pagination hangs off it: `{permalink}page/2/`.
-    if (pages.posts !== undefined) {
-        const request = postsPageRequest(pages.posts, pathname);
-        if (request !== undefined) {
-            // `{permalink}page/1/` is the listing's own URL spelled twice, and
-            // collapses onto it exactly as `/page/1/` collapses onto `/`.
-            if (request.pageNumber === 0 && pathname !== pages.posts.permalink) {
-                return c.redirect(encodePath(pages.posts.permalink), 301);
-            }
-            return listing(c, request);
-        }
-    }
-    const feedRequest = parseFeedPath(c, pathname, bases, authors);
-    if (feedRequest !== undefined) {
-        const { target, format } = feedRequest;
-        const canonical = feedTargetHref(target, format, bases);
-        if (!feedRequest.canonical ||
-            (target.kind === 'listing' && canonical !== encodePath(pathname))) {
-            return c.redirect(canonical, 301);
-        }
-        return target.kind === 'listing'
-            ? feed(c, format, target.subject)
-            : comments(c, target.document);
-    }
-    const archive = taxonomyArchive(c, pathname, bases, authors);
-    if (archive !== undefined)
-        return archive;
-    // And one person's, which is the same kind of thing at a path the site
-    // reserves: `author` is never a document's first segment, so this can be
-    // answered before the permalink lookup without anything being shadowed.
-    const byAuthor = authorArchive(c, pathname, bases, authors);
-    if (byAuthor !== undefined)
-        return byAuthor;
-    const document = publicDocumentAt(store, pathname);
-    if (document !== undefined) {
-        // The front page has one URL. The page it is made of keeps its own
-        // permalink in the file, so that a homepage put back to being an ordinary
-        // page goes back to answering there, and that URL points at `/` while it
-        // is the front page.
-        if (document.path === pages.home?.path)
-            return c.redirect('/', 301);
-        // WordPress answered `?feed=rss2` on a permalink with that document's
-        // comments feed, which is the only feed a document has here too. The other
-        // spellings name a format a comments feed does not come in, so they are
-        // not a feed request at all and the page is served.
-        if (queryFeedFormat(c) === 'rss' && showsConversation(c, document)) {
-            return c.redirect(commentsFeedHref(document), 301);
+    const search = requestSearch(c);
+    const here = encodePath(pathname);
+    const match = classifyPath(view, pathname);
+    if (match !== undefined) {
+        const href = canonicalHref(view, match);
+        if (href !== here || (match.kind === 'feed' && !match.canonical)) {
+            return c.redirect(`${href}${search}`, 301);
         }
-        return negotiateDocument(c, document, selectFromAccept(c, DOCUMENT_REPRESENTATIONS));
+        return serve(c, view, match);
     }
     const hidden = hiddenDocumentForSignedInHtml(c, pathname);
     if (hidden !== undefined)
         return hidden;
-    const { search } = new URL(c.req.url);
     const extension = splitRepresentationExtension(pathname);
     if (extension !== undefined) {
-        const canonicalRedirect = (candidate) => {
-            const href = representationHref(encodePath(candidate), extension.representation);
-            return href === encodePath(pathname) ? undefined : `${href}${search}`;
-        };
+        const { representation } = extension;
         for (const candidate of extension.paths) {
-            // `/index.md` and `/index.json` are the front page's own
-            // representations on a site whose `/` is a page: the document is at `/`
-            // however it is asked for.
-            const found = candidate === '/' ? pages.home : publicDocumentAt(store, candidate);
-            const servesListing = found !== undefined && found.path === pages.posts?.path;
-            if (found !== undefined && !servesListing) {
-                const canonical = canonicalRedirect(candidate);
-                if (canonical !== undefined)
-                    return c.redirect(canonical, 301);
-                return negotiateDocument(c, found, extension.representation, candidate === '/' ? '/' : undefined);
-            }
-        }
-        // `/index.json`, `/page/2/index.json`, `/tag/x/index.json`,
-        // `/category/x/index.json`: the same escape hatch over a listing, for the
-        // representations a listing has.
-        if (LISTING_REPRESENTATIONS.includes(extension.representation)) {
-            for (const candidate of extension.paths) {
-                const request = listingRequestAt(store, pages, candidate, bases, authors);
-                if (request === undefined)
-                    continue;
-                const canonical = canonicalRedirect(candidate);
-                if (canonical !== undefined)
-                    return c.redirect(canonical, 301);
-                return listing(c, request, extension.representation);
-            }
+            const found = classifyPath(view, candidate);
+            if (found === undefined || found.kind === 'feed')
+                continue;
+            if (found.kind === 'listing' && !LISTING_REPRESENTATIONS.includes(representation))
+                continue;
+            const href = representationHref(canonicalHref(view, found), representation);
+            if (href !== here)
+                return c.redirect(`${href}${search}`, 301);
+            return found.kind === 'listing'
+                ? listing(c, found, representation)
+                : negotiateDocument(c, found.document, representation);
         }
     }
     // Nothing lives here, so a URL something used to live at leads on to where
     // it lives now. Asked only after every live lookup, which is what lets a new
     // document take an old URL over, and a term that comes back into use beat
     // the record of what it was renamed to.
-    const formerly = movedHref(store, pages, pathname, undefined) ??
+    const formerly = movedHref(view, pathname, undefined) ??
         extension?.paths
-            .map((candidate) => movedHref(store, pages, candidate, extension.representation))
+            .map((candidate) => movedHref(view, candidate, extension.representation))
             .find((href) => href !== undefined) ??
-        renamedTermHref(c, pathname, bases);
+        renamedTermHref(c, view, pathname);
     if (formerly !== undefined)
         return c.redirect(`${formerly}${search}`, 301);
-    const deleted = [pathname, ...(extension?.paths ?? [])].some((candidate) => goneDocumentAt(store, candidate) !== undefined);
+    const deleted = [pathname, ...(extension?.paths ?? [])].some((candidate) => goneDocumentAt(view.store, candidate) !== undefined);
     if (deleted)
         return gone(c);
-    const canonical = canonicalPath(c, pathname, bases, authors);
-    if (canonical !== undefined)
-        return c.redirect(canonical, 301);
+    const slashed = slashedHref(view, pathname, c.var.renderer.pageSize());
+    if (slashed !== undefined)
+        return c.redirect(`${slashed}${search}`, 301);
     // And a URL the site itself says has moved (TASK-128), after every live
     // lookup and after the slash that would lead to one, so a declared source
     // never shadows a live document.
@@ -401,55 +238,25 @@ function resolveRequest(c) {
     }
     return notFound(c);
 }
-/**
- * Where the document that used to live at a URL lives now, in the
- * representation asked for, or `undefined` when no published document names
- * the URL in its `redirect_from` (TASK-127).
- */
-function movedHref(store, pages, pathname, representation) {
-    const document = store.getByFormerPermalink(pathname);
-    if (document === undefined)
-        return undefined;
-    const href = document.path === pages.home?.path ? '/' : encodePath(document.permalink);
-    return representation === undefined ? href : representationHref(href, representation);
-}
-/**
- * One taxonomy archive, the redirect that puts it at its canonical URL, or
- * `undefined` when the path is not one.
- *
- * `/{base}/x/page/1/` collapses onto the archive root the way `/page/1/`
- * collapses onto the home page, and any other casing of a term collapses onto
- * the site's spelling of it (TASK-339). A term nothing carries is not an
- * archive at all, so the request goes on to the renames and the declared
- * redirects that may know where it went.
- */
-function taxonomyArchive(c, pathname, bases, authors) {
-    if (!pathname.endsWith('/'))
-        return undefined;
-    const request = parseListingPath(c.var.store, pathname, bases, authors);
-    if (request?.term === undefined)
-        return undefined;
-    const canonical = termHref(request.term, request.pageNumber, bases);
-    if (canonical !== encodePath(pathname)) {
-        return c.redirect(`${canonical}${new URL(c.req.url).search}`, 301);
+function serve(c, view, match) {
+    switch (match.kind) {
+        case 'listing':
+            return listing(c, match);
+        case 'feed':
+            return match.target.kind === 'listing'
+                ? feed(c, match.format, match.target.subject)
+                : comments(c, match.target.document);
+        case 'document':
+            // WordPress answered `?feed=rss2` on a permalink with that document's
+            // comments feed, which is the only feed a document has here too. The
+            // other spellings name a format a comments feed does not come in, so
+            // they are not a feed request at all and the page is served.
+            if (queryFeedFormat(c) === 'rss' && view.showsConversation(match.document)) {
+                return c.redirect(commentsFeedHref(match.document), 301);
+            }
+            return negotiateDocument(c, match.document, selectFromAccept(c, DOCUMENT_REPRESENTATIONS));
     }
-    return listing(c, request);
 }
-/**
- * One person's archive, the redirect that puts it at its canonical URL, or
- * `undefined` when the path is not one.
- *
- * Unlike a taxonomy archive it does not depend on there being anything on it.
- * A tag exists only while something carries it; a person exists because they
- * have an account, and after decision-14 this URL is the id their followers
- * file them under — so an archive that 404'd until its owner published would
- * be an account that came into being with a post. What decides the 404 is
- * whether the username is somebody's, which {@link parseListingPath} has
- * already asked.
- *
- * `/author/{username}/page/1/` collapses onto the archive root the way
- * `/page/1/` collapses onto the home page.
- */
 function hiddenDocumentForSignedInHtml(c, pathname) {
     if (c.var.signedIn === undefined)
         return undefined;
@@ -458,17 +265,6 @@ function hiddenDocumentForSignedInHtml(c, pathname) {
     const hidden = previewDocumentAt(c.var.store, pathname);
     return hidden === undefined ? undefined : negotiateDocument(c, hidden, 'html');
 }
-function authorArchive(c, pathname, bases, authors) {
-    if (!pathname.endsWith('/'))
-        return undefined;
-    const request = parseListingPath(c.var.store, pathname, bases, authors);
-    if (request?.author === undefined)
-        return undefined;
-    const canonical = authorHref(request.author.user.username, request.pageNumber);
-    if (canonical !== encodePath(pathname))
-        return c.redirect(canonical, 301);
-    return listing(c, request);
-}
 /**
  * Where a renamed term's archive page or feed lives now, or `undefined` when
  * the path is neither or the site records no rename of its term.
@@ -477,9 +273,9 @@ function authorArchive(c, pathname, bases, authors) {
  * to the old feed follows it to the new one, exactly as a reader of the archive
  * does.
  */
-function renamedTermHref(c, pathname, bases) {
+function renamedTermHref(c, view, pathname) {
     const feedPath = splitFeedPath(pathname);
-    const asked = parseTermPath(feedPath?.root ?? pathname, bases);
+    const asked = parseTermPath(view, feedPath?.root ?? pathname);
     if (asked === undefined || (feedPath !== undefined && asked.pageNumber !== 0))
         return undefined;
     const to = redirectedTerm(c.var.renderer.termRedirects(), asked.term);
@@ -487,1074 +283,7 @@ function renamedTermHref(c, pathname, bases) {
         return undefined;
     const moved = { taxonomy: asked.term.taxonomy, term: to };
     return feedPath === undefined
-        ? termHref(moved, asked.pageNumber, bases)
-        : feedHref(moved, feedPath.format, bases);
-}
-/**
- * A path as the feed it names: `/feed/`, `/feed/atom/`, `/{base}/x/feed/json/`,
- * the comments feeds at `/comments/feed/` and `{permalink}feed/`, and the
- * `/feed/rss/` spelling WordPress also answered at any of those roots.
- *
- * The site's own canonical feeds are real routes and never reach here; what
- * does reach here is every taxonomy feed — their bases are a setting, so they
- * cannot be in the route table — every document's comments feed, and every alias.
- */
-function parseFeedPath(c, pathname, bases, authors) {
-    const { store } = c.var;
-    const split = splitFeedPath(pathname);
-    if (split === undefined)
-        return undefined;
-    const { format, canonical } = split;
-    if (split.root === COMMENTS_ROOT) {
-        return format === 'rss'
-            ? { target: { kind: 'comments', document: undefined }, format, canonical }
-            : undefined;
-    }
-    const root = parseListingPath(store, split.root, bases, authors);
-    // Only a listing root has a feed, and only its first page: a feed is not
-    // paginated, so `/{base}/x/page/2/feed/` names nothing.
-    if (root !== undefined) {
-        return root.pageNumber === 0
-            ? { target: { kind: 'listing', subject: root }, format, canonical }
-            : undefined;
-    }
-    // Otherwise it may be a document's comments feed, which it has exactly when
-    // its page shows its conversation.
-    if (format !== 'rss')
-        return undefined;
-    const document = publicDocumentAt(store, split.root);
-    if (document === undefined || !showsConversation(c, document))
-        return undefined;
-    return { target: { kind: 'comments', document }, format, canonical };
-}
-/** Whether this document's page shows its conversation, and so has a comments feed. */
-function showsConversation(c, document) {
-    return answerable(document, commentPolicyOf(c.var.renderer.site()), c.var.store.now());
-}
-/** Where the canonical URL of one feed is. */
-function feedTargetHref(target, format, bases) {
-    return target.kind === 'listing'
-        ? listingFeedHref(target.subject, format, bases)
-        : commentsFeedHref(target.document);
-}
-/**
- * The format `?feed=` asked for, WordPress's pre-permalink spelling, or
- * `undefined` when the request did not ask for a feed at all.
- *
- * `rss2` is what WordPress calls RSS 2.0 and `rss` its RSS 0.92, which this
- * site does not serve and answers with the RSS 2.0 feed rather than a 404.
- */
-function queryFeedFormat(c) {
-    const asked = c.req.query('feed');
-    if (asked === undefined)
-        return undefined;
-    if (asked === 'rss2' || asked === 'rss')
-        return 'rss';
-    return FEED_FORMATS.find((format) => FEED_SEGMENTS[format] === asked);
-}
-/**
- * What the query string puts on a rendered post, if anything.
- *
- * A reader has no session, so the message after a submission travels in the
- * URL and is read back here. An unknown value says nothing at all rather than
- * being printed, so the query cannot be used to put words on somebody's post.
- */
-function commentNotice(c, document, viewer) {
-    const notice = commentNoticeFor(c.req.query(COMMENT_NOTICE_PARAM));
-    return {
-        ...(notice === undefined ? {} : { commentNotice: notice }),
-        // And who a Reply link says the form is answering, which travels the same
-        // way and for the same reason: a reader has no session, and threading
-        // should not need a line of JavaScript.
-        ...commentReplyTarget({
-            admin: c.var.admin,
-            document,
-            id: c.req.query(COMMENT_REPLY_PARAM),
-            thread: viewer === undefined ? undefined : c.var.conversation.thread(document),
-        }),
-        // And the thank-you after a contact form was sent, which travels the same
-        // way for the same reason (TASK-56).
-        ...contactNotice(c),
-    };
-}
-/**
- * The thank-you a contact form's redirect landed on, if the query names one.
- *
- * On the context rather than in the form's own state because the redirect is
- * what makes a refresh harmless: the page is drawn fresh, and the query is the
- * only thing that says a message went.
- */
-function contactNotice(c) {
-    const notice = contactNoticeFor(c.req.query(CONTACT_NOTICE_PARAM));
-    return notice === undefined ? {} : { contactNotice: notice };
-}
-/** The representation an `Accept` header asked for, or `undefined` for a 406. */
-function selectFromAccept(c, available) {
-    return selectRepresentation(c.req.header('accept'), available);
-}
-/**
- * One document in one representation, or the 406 an impossible `Accept` earns.
- *
- * `href` is where it is being served, which is its own permalink everywhere
- * but the front page: a page serving as the homepage is read at `/`, and the
- * canonical URL, the alternates and the theme's own links have to say so.
- */
-function negotiateDocument(c, document, representation, href = document.permalink) {
-    if (representation === undefined) {
-        return notAcceptableResponse(encodePath(href), DOCUMENT_REPRESENTATIONS);
-    }
-    // Who the request's session says is reading, when it says anybody
-    // (TASK-103). Only the HTML has a form on it, so only the HTML asks; the
-    // Markdown and JSON of a post are the same bytes for everybody.
-    const account = representation === 'html' ? c.var.signedIn : undefined;
-    const viewer = account === undefined ? undefined : commenterOf(account);
-    // And which document it is, so the admin bar can offer its editor.
-    if (representation === 'html')
-        c.set('shownDocument', document);
-    const listed = isListed(document, c.var.store.now());
-    // The thank-you after a comment was posted, which the redirect carried back
-    // as a query, is the only thing about a document's HTML that the URL rather
-    // than the file decides. A document served at `/` is the site's front page,
-    // and the front page is the one place a theme may lay a page out differently.
-    const page = representation === 'html'
-        ? c.var.renderer.renderPage(document, {
-            frontPage: href === '/',
-            extra: { ...commentNotice(c, document, viewer), ...(listed ? {} : { noindex: true }) },
-            viewer,
-        })
-        : undefined;
-    const markdown = representation === 'markdown' || representation === 'text'
-        ? documentMarkdown(document)
-        : undefined;
-    const body = markdown ??
-        (representation === 'json'
-            ? documentJson(document, { baseUrl: c.var.config.baseUrl })
-            : page?.html);
-    const response = representationResponse({
-        body,
-        representation,
-        href: encodePath(href),
-        available: DOCUMENT_REPRESENTATIONS,
-        noindex: !listed,
-        // Where a webmention about this page is sent. It is a header rather than
-        // only a `<link>` because a sender is allowed to find the endpoint without
-        // parsing the page, and because the JSON and Markdown representations of a
-        // post have no head to put one in (TASK-51).
-        links: webmentionLinks(c),
-        // A page drawn for one named reader is that reader's page rather than the
-        // post, so nothing shared may hold it and it carries no validator. A page
-        // drawn for everybody is exactly what it has always been.
-        ...(viewer === undefined ? {} : { private: true }),
-        // The JSON is the file, so the file's hash and dates validate it. The HTML
-        // also draws the theme, the conversation, the neighbours and whatever else
-        // the site holds, none of which the file's hash sees, so it is validated by
-        // the page it drew (TASK-181). Nothing records when a withdrawn reply
-        // stopped being shown, so the HTML has no date that could agree with that
-        // ETag and carries no Last-Modified.
-        ...(page === undefined
-            ? {
-                etag: representationEtag(representation, markdown ?? document.hash),
-                lastModified: lastModifiedOf(document),
-            }
-            : { etag: representationEtag(representation, page.fingerprint) }),
-        conditional: conditionalHeaders(c),
-    });
-    const pingback = pingbackEndpointFor(c.var.renderer.site(), document, c.var.config.now());
-    if (pingback !== undefined) {
-        response.headers.set('x-pingback', absoluteUrl(pingback, c.var.config.baseUrl));
-    }
-    return response;
-}
-/**
- * The `Link` header advertising this site's webmention endpoint, or none when
- * the site does not take them.
- *
- * Read per request off the settings, so turning webmentions off on the
- * settings screen takes the advertisement off the very next page rather than
- * off the next restart.
- */
-function webmentionLinks(c) {
-    if (!readSiteSettings(c.var.config.contentDir).webmentionsReceive)
-        return [];
-    return [`<${WEBMENTION_PATH}>; rel="webmention"`];
-}
-/** The conditional request headers, as the negotiator wants them. */
-function conditionalHeaders(c) {
-    return {
-        ifNoneMatch: c.req.header('if-none-match'),
-        ifModifiedSince: c.req.header('if-modified-since'),
-    };
-}
-/**
- * The canonical URL for a path that arrived without its trailing slash, or
- * `undefined` when adding one would not resolve either.
- *
- * Redirecting only to somewhere real means a genuinely missing URL costs one
- * 404 rather than a redirect and then a 404. The target is the canonical URL
- * itself rather than the path with a slash bolted on, so `/page/1` lands on
- * `/` in one hop instead of two.
- */
-function canonicalPath(c, pathname, bases, authors) {
-    if (pathname === '' || pathname.endsWith('/'))
-        return undefined;
-    const target = canonicalTarget(c, `${pathname}/`, bases, authors);
-    if (target === undefined)
-        return undefined;
-    return `${target}${new URL(c.req.url).search}`;
-}
-/** Where a path with a trailing slash canonically lives, if anywhere. */
-function canonicalTarget(c, pathname, bases, authors) {
-    const { store, renderer } = c.var;
-    // A feed first: `/feed`, `/feed/atom`, `/{base}/x/feed`, `/comments/feed`
-    // and a document's `{permalink}feed` all lead somewhere real, and `/feed/rss`
-    // leads to `/feed/` in the same one hop rather than to a second redirect.
-    const feedRequest = parseFeedPath(c, pathname, bases, authors);
-    if (feedRequest !== undefined) {
-        return feedTargetHref(feedRequest.target, feedRequest.format, bases);
-    }
-    const pages = frontPages(c);
-    const document = store.getByPermalink(pathname);
-    if (document !== undefined) {
-        if (!isServed(document))
-            return undefined;
-        // The homepage's own URL leads to `/` rather than to the redirect that
-        // leads to `/`: one hop, the way `/page/1` reaches `/` in one.
-        return document.path === pages.home?.path ? '/' : encodePath(pathname);
-    }
-    const moved = movedHref(store, pages, pathname, undefined);
-    if (moved !== undefined)
-        return moved;
-    const listing = listingRequestAt(store, pages, pathname, bases, authors);
-    if (listing === undefined)
-        return undefined;
-    const total = countListing(store, listing);
-    const totalPages = Math.max(1, Math.ceil(total / renderer.pageSize()));
-    if (listing.pageNumber >= totalPages)
-        return undefined;
-    return listingHref(listing, listing.pageNumber, bases, listing.document?.permalink ?? '/');
-}
-/** {@link AuthorLookup} over one request's site. */
-function authorsOf(c) {
-    let users;
-    return (username) => {
-        users ??= listUsers(c.var.config.dataDir);
-        const user = users.find((candidate) => candidate.username === username);
-        return user === undefined ? undefined : { user, names: authorNames(users, user) };
-    };
-}
-/**
- * WordPress's Reading choice, resolved for this request.
- *
- * The setting holds slugs, and a slug is only a front page while it names a
- * page the public site would serve: one drafted, trashed or deleted since it
- * was picked resolves to nothing, and a site whose homepage resolves to
- * nothing is a site showing its latest posts again. That is the whole of the
- * fallback — there is no state to repair and nothing to write — and it is why
- * the pick is kept rather than cleared: publishing the page again puts the
- * front page back.
- */
-function frontPages(c) {
-    const { homepage, postsPage } = c.var.renderer.frontPageSlugs();
-    const home = publicPage(c, homepage);
-    return {
-        home,
-        // Without a homepage there is no posts page: the listing is already at
-        // `/`, and a second URL for it is exactly what this pair exists to avoid.
-        posts: home === undefined ? undefined : publicPage(c, postsPage),
-    };
-}
-/**
- * A path as the page of a listing it names, wherever the listing lives, or
- * `undefined` when it names none.
- *
- * The posts page first, because its permalink is the listing's root on a site
- * that has one; then the ordinary `/`, `/page/N/` and the taxonomy archives.
- * A site whose homepage is a page and which named no posts page has no home
- * listing at all, so nothing under the root is one either.
- */
-function listingRequestAt(store, pages, pathname, bases, authors) {
-    const onPostsPage = pages.posts === undefined ? undefined : postsPageRequest(pages.posts, pathname);
-    if (onPostsPage !== undefined)
-        return onPostsPage;
-    const request = parseListingPath(store, pathname, bases, authors);
-    if (request === undefined)
-        return undefined;
-    // Only the home listing can be homeless. A tag archive and a person's
-    // archive have URLs of their own, whatever the Reading setting says `/` is.
-    if (request.term === undefined && request.author === undefined) {
-        if (listingRoot(pages) === undefined)
-            return undefined;
-    }
-    return request;
-}
-/**
- * Where the post listing lives, or `undefined` when it has no page at all.
- *
- * A site showing its latest posts has it at `/`; a site with a posts page has
- * it there; a site whose homepage is a page and which named no posts page has
- * nowhere for it, which is WordPress's own answer and the reason its Reading
- * screen offers the second pick. The feeds are unaffected either way.
- */
-function listingRoot(pages) {
-    if (pages.posts !== undefined)
-        return pages.posts.permalink;
-    return pages.home === undefined ? '/' : undefined;
-}
-/** The published page one slug names, or `undefined`. */
-function publicPage(c, slug) {
-    if (slug === '')
-        return undefined;
-    const found = c.var.store.getBySlug(slug);
-    if (found?.type !== 'page')
-        return undefined;
-    return isServed(found, c.var.store.now()) ? found : undefined;
-}
-/**
- * `{permalink}` or `{permalink}page/N/` as a page of the listing the posts
- * page carries, or `undefined` when the path is neither.
- *
- * `page/1/` is not one: the first page of a listing lives at the listing's own
- * URL, exactly as `/page/1/` collapses onto `/`, and the canonicalisation that
- * says so is the ordinary one.
- */
-function postsPageRequest(document, pathname) {
-    const { permalink } = document;
-    if (pathname === permalink)
-        return { term: undefined, pageNumber: 0, document };
-    if (!pathname.startsWith(permalink))
-        return undefined;
-    const segments = pathname
-        .slice(permalink.length)
-        .split('/')
-        .filter((segment) => segment !== '');
-    if (segments.length !== 2 || segments[0] !== PAGE_SEGMENT || !pathname.endsWith('/')) {
-        return undefined;
-    }
-    const page = pageIndex(segments[1]);
-    return page === undefined ? undefined : { term: undefined, pageNumber: page, document };
-}
-/**
- * `/`, `/page/N/`, `/author/{username}/` and `/author/{username}/page/N/`, and
- * either taxonomy's `/{base}/x/` and `/{base}/x/page/N/`, as a listing to
- * check.
- */
-function parseListingPath(store, pathname, bases, authors) {
-    const segments = pathname.split('/').filter((segment) => segment !== '');
-    if (segments.length === 0)
-        return { term: undefined, pageNumber: 0 };
-    if (segments[0] === PAGE_SEGMENT && segments.length === 2) {
-        const page = pageIndex(segments[1]);
-        return page === undefined ? undefined : { term: undefined, pageNumber: page };
-    }
-    // One person's archive, at the path decision-14 reserves. A username nobody
-    // has is not a listing at all, which is what turns it into one 404 rather
-    // than an empty archive.
-    const byAuthor = parseAuthorPath(pathname);
-    if (byAuthor !== undefined) {
-        const found = authors(byAuthor.username);
-        return found === undefined ? undefined : { author: found, pageNumber: byAuthor.pageNumber };
-    }
-    // A taxonomy archive exists only while a published post carries the term,
-    // so a term nothing carries is not a listing, whatever its path says.
-    const asked = parseTermPath(pathname, bases);
-    if (asked === undefined)
-        return undefined;
-    const spelled = carriedSpelling(store, asked.term);
-    return spelled === undefined
-        ? undefined
-        : { term: { ...asked.term, term: spelled }, pageNumber: asked.pageNumber };
-}
-/**
- * `/{base}/x/` and `/{base}/x/page/N/` as the term and page they name, as the
- * path spells them, whether or not anything carries the term.
- */
-function parseTermPath(pathname, bases) {
-    const segments = pathname.split('/').filter((segment) => segment !== '');
-    const taxonomy = taxonomyForSegment(segments[0], bases);
-    const named = segments[1];
-    if (taxonomy === undefined || named === undefined)
-        return undefined;
-    const term = { taxonomy, term: named };
-    if (segments.length === 2)
-        return { term, pageNumber: 0 };
-    if (segments.length === 4 && segments[2] === PAGE_SEGMENT) {
-        const page = pageIndex(segments[3]);
-        return page === undefined ? undefined : { term, pageNumber: page };
-    }
-    return undefined;
-}
-/**
- * How the site spells a term some published post carries, matched without
- * regard to case, or `undefined` when none carries it (TASK-339).
- *
- * A tag's casings are one term (TASK-308). A category stays as spelled, so a
- * category carried in exactly the asked spelling wins, and otherwise the most
- * used one that differs only in case: WordPress lower-cased every slug, so an
- * imported `/category/rsscloud/` names the category spelled `rssCloud`.
- */
-function carriedSpelling(store, term) {
-    if (term.taxonomy === 'tag') {
-        return store.countByTag(term.term) > 0 ? store.tagSpelling(term.term) : undefined;
-    }
-    if (store.countByCategory(term.term) > 0)
-        return term.term;
-    const key = term.term.toLowerCase();
-    return store.listCategories().find(({ category }) => category.toLowerCase() === key)?.category;
-}
-/** How many published documents a listing holds. */
-function countListing(store, subject) {
-    const { term, author } = subject;
-    if (author !== undefined)
-        return store.countByAuthor(author.names);
-    if (term === undefined)
-        return store.counts().posts;
-    return term.taxonomy === 'tag' ? store.countByTag(term.term) : store.countByCategory(term.term);
-}
-/** One page of a listing's documents, newest first. */
-function listListing(store, subject, paging) {
-    const { term, author } = subject;
-    if (author !== undefined)
-        return store.listByAuthor(author.names, paging);
-    if (term === undefined)
-        return store.listPosts(paging);
-    return term.taxonomy === 'tag'
-        ? store.listByTag(term.term, paging)
-        : store.listByCategory(term.term, paging);
-}
-/**
- * The URL of a page of a listing: the home archive's, or a taxonomy's.
- *
- * `root` is where the home listing lives — `/`, or the posts page's permalink
- * on a site that has one — so every link the listing draws, every canonical
- * redirect and the sitemap all spell its pages the same way.
- */
-function listingHref(subject, index, bases, root = '/') {
-    const { term, author } = subject;
-    if (author !== undefined)
-        return authorHref(author.user.username, index);
-    return term === undefined ? listingPageHref(root, index) : termHref(term, index, bases);
-}
-/**
- * The URL of one format of one listing's feed, whichever kind of listing it is.
- *
- * The site's and a taxonomy's hang off the listing root; a person's hangs off
- * their archive, which decision-14 keeps at WordPress's `/author/{username}/`
- * rather than under the listing machinery, because that root is also an actor
- * id.
- */
-function listingFeedHref(subject, format, bases) {
-    return subject.author === undefined
-        ? feedHref(subject.term, format, bases)
-        : authorFeedHref(subject.author.user.username, format);
-}
-/**
- * A `/page/N/` segment as a zero-based index. `page/1` parses to the first
- * page, which lives at the listing root, so canonicalisation collapses it.
- */
-function pageIndex(segment) {
-    if (segment === undefined || !/^[0-9]+$/.test(segment))
-        return undefined;
-    const requested = Number(segment);
-    return requested < 1 ? undefined : requested - 1;
-}
-/** One page of a listing, in whichever representation the request settled on. */
-function listing(c, request, representation = selectFromAccept(c, LISTING_REPRESENTATIONS)) {
-    const { store, renderer } = c.var;
-    const { term, author } = request;
-    const size = renderer.pageSize();
-    const bases = renderer.taxonomyBases();
-    // Where this listing's pages live: the posts page's permalink when the site
-    // has one, and the site root otherwise.
-    const root = request.document?.permalink ?? '/';
-    // WordPress served every feed as a query on the listing before it served one
-    // at a path, and the links are still out there. `/?feed=rss2` and
-    // `/{base}/x/?feed=atom` land on the feed the listing now has.
-    const asked = queryFeedFormat(c);
-    if (asked !== undefined)
-        return c.redirect(listingFeedHref(request, asked, bases), 301);
-    const total = countListing(store, request);
-    const href = listingHref(request, request.pageNumber, bases, root);
-    const pagination = paginate({
-        total,
-        size,
-        pageNumber: request.pageNumber,
-        hrefForPage: (index) => listingHref(request, index, bases, root),
-    });
-    if (request.pageNumber >= pagination.totalPages)
-        return notFound(c);
-    if (representation === undefined)
-        return notAcceptableResponse(href, LISTING_REPRESENTATIONS);
-    const paging = { limit: size, offset: offsetForPage(request.pageNumber, size) };
-    const documents = listListing(store, request, paging);
-    const title = term?.term ??
-        author?.user.profile?.displayName ??
-        author?.user.username ??
-        request.document?.title ??
-        renderer.site().title;
-    if (representation === 'markdown' || representation === 'text') {
-        return listingMarkdown(c, request, representation, { href, title, pagination, documents });
-    }
-    const full = wantsFullDocuments(c);
-    const body = representation === 'json'
-        ? documents.map((document) => documentJson(document, { baseUrl: c.var.config.baseUrl, body: full }))
-        : renderer.renderListing({
-            title,
-            url: href,
-            documents,
-            pagination,
-            // And its words go above the posts, which is what a posts page is
-            // for: a theme prints `{{ content | safe }}` over the list.
-            ...(request.document === undefined ? {} : { document: request.document }),
-            ...(term === undefined ? {} : taxonomyContext(term)),
-            ...(author === undefined ? {} : authorArchiveContext(author)),
-        });
-    const validated = representation !== 'html' || !c.var.config.watch;
-    return representationResponse({
-        body,
-        representation,
-        href,
-        available: LISTING_REPRESENTATIONS,
-        ...(drawnForSomebody(c, representation) ? { private: true } : {}),
-        ...(validated
-            ? {
-                etag: representationEtag(representation, listingFingerprint(href, pagination, documents, full)),
-                lastModified: latestModified(documents),
-            }
-            : {}),
-        conditional: conditionalHeaders(c),
-    });
-}
-function listingMarkdown(c, request, representation, page) {
-    const { next, previous } = page.pagination.href;
-    const home = frontPages(c).home;
-    const latestPosts = request.term === undefined && request.author === undefined;
-    const description = request.document?.description ?? (latestPosts ? c.var.renderer.site().tagline : undefined);
-    const body = llmsListingTxt({
-        title: page.title,
-        description,
-        posts: page.documents.map((document) => llmsEntry(c, document, home)),
-        newer: previous === null ? undefined : representationHref(previous, 'markdown'),
-        older: next === null ? undefined : representationHref(next, 'markdown'),
-    }, c.var.config.baseUrl);
-    return representationResponse({
-        body,
-        representation,
-        href: page.href,
-        available: LISTING_REPRESENTATIONS,
-        etag: representationEtag(representation, body),
-        lastModified: latestModified(page.documents),
-        conditional: conditionalHeaders(c),
-    });
-}
-function documentMarkdown(document) {
-    const title = document.title.replace(/\s+/g, ' ').trim();
-    if (title === '' || /^#[ \t]/.test(document.body.trimStart()))
-        return serializeDocument(document);
-    return serializeDocument({ ...document, body: `# ${title}\n\n${document.body}` });
-}
-/**
- * One page of search results, in whichever representation the request settled
- * on.
- *
- * What it finds is what the listings would show: the index holds the search to
- * published, untrashed, already-due documents, so a draft cannot be found by
- * its words any more than it can be found by its URL. A search with no query
- * is the page with the form on it and nothing found, rather than an error,
- * because that is where a link to the search from a theme lands. A page past
- * the last one 404s, as it does on a listing.
- */
-function search(c, representation) {
-    const { store, renderer, config } = c.var;
-    const query = searchQuery(c.req.query(SEARCH_QUERY_PARAM));
-    const pageNumber = searchPageIndex(c.req.query(SEARCH_PAGE_PARAM));
-    if (pageNumber === undefined)
-        return notFound(c);
-    const size = renderer.pageSize();
-    const pagination = paginate({
-        total: store.countSearch(query),
-        size,
-        pageNumber,
-        hrefForPage: (index) => searchHref(query, index),
-    });
-    if (pageNumber >= pagination.totalPages)
-        return notFound(c);
-    const href = searchHref(query, pageNumber);
-    if (representation === undefined)
-        return notAcceptableResponse(href, SEARCH_REPRESENTATIONS);
-    const hits = store.search(query, { limit: size, offset: offsetForPage(pageNumber, size) });
-    const documents = hits.map((hit) => hit.document);
-    const full = wantsFullDocuments(c);
-    const body = representation === 'json'
-        ? searchJson({ query, hits, pagination, baseUrl: config.baseUrl, body: full })
-        : renderer.renderSearch({ query, url: href, hits, pagination });
-    const validated = representation !== 'html' || !config.watch;
-    return representationResponse({
-        body,
-        representation,
-        href,
-        // The alternates are spelled here rather than by the negotiator, because
-        // they carry the query and a listing's never have one to carry.
-        available: [representation],
-        links: SEARCH_REPRESENTATIONS.filter((other) => other !== representation).map((other) => `<${searchHref(query, pageNumber, other)}>; rel="alternate"; type="${MEDIA_TYPES[other]}"`),
-        ...(drawnForSomebody(c, representation) ? { private: true } : {}),
-        ...(validated
-            ? {
-                etag: representationEtag(representation, listingFingerprint(href, pagination, documents, full)),
-                lastModified: latestModified(documents),
-            }
-            : {}),
-        conditional: conditionalHeaders(c),
-    });
-}
-/**
- * Whether this is a page drawn for a signed-in reader, which carries the admin
- * bar (TASK-183) and so must never be answered with a 304 off the validators of
- * the copy an anonymous visit left in their browser.
- */
-function drawnForSomebody(c, representation) {
-    return representation === 'html' && c.var.signedIn !== undefined;
-}
-/**
- * Whether the request asked for whole documents rather than summaries.
- *
- * Anything but an explicit denial counts, so `?full`, `?full=1` and `?full=yes`
- * all mean the same thing to someone typing a URL by hand.
- */
-function wantsFullDocuments(c) {
-    const value = c.req.query('full');
-    return value !== undefined && value !== '0' && value.toLowerCase() !== 'false';
-}
-/**
- * What a listing page is made of, as one string to hash.
- *
- * The documents on the page are not the whole story: the same two posts on a
- * differently sized archive are a different page, and a summary is not the
- * body, so the pagination and the `full` flag are in the fingerprint too.
- */
-function listingFingerprint(href, pagination, documents, full) {
-    return [
-        href,
-        `${String(pagination.pageNumber)}/${String(pagination.totalPages)}/${String(pagination.total)}`,
-        full ? 'full' : 'summary',
-        ...documents.map((document) => document.hash),
-    ].join('\n');
-}
-/**
- * The site's feed, or one archive's, in one format.
- *
- * A term with nothing published under it 404s exactly as its archive does: a
- * feed reader should be told the URL is wrong rather than handed an empty feed
- * it will poll forever.
- */
-function feed(c, format, subject) {
-    const { store, renderer, config } = c.var;
-    const site = renderer.site();
-    const bases = renderer.taxonomyBases();
-    const { term, author } = subject;
-    const documents = listListing(store, subject, { limit: feedSize(site) });
-    const href = listingHref(subject, 0, bases);
-    // What the feed calls itself: the site, and then the term or the person it
-    // is about, so a reader subscribed to several of a site's feeds can tell
-    // them apart in a list.
-    const about = term?.term ?? author?.user.profile?.displayName ?? author?.user.username;
-    const source = {
-        site,
-        users: listUsers(config.dataDir),
-        documents,
-        title: about === undefined ? site.title : `${site.title}: ${about}`,
-        href,
-        feedHref: listingFeedHref(subject, format, bases),
-        baseUrl: config.baseUrl,
-        // Only RSS carries the comment pointers; the other two formats have no
-        // vocabulary for them, and counting for a feed that cannot say the number
-        // would be a query per item for nothing.
-        ...(format === 'rss' ? { commentCounts: c.var.conversation.counts(documents) } : {}),
-        altTexts: readAltTexts(config.contentDir),
-        replyContext: (target) => c.var.replyContexts.read(target),
-    };
-    return feedResponse({ format, source, conditional: conditionalHeaders(c) });
-}
-/**
- * A post's or page's comments, or the whole site's, as RSS 2.0.
- *
- * A document with no replies answers an empty feed rather than a 404: it
- * exists, and a reader that subscribed before anybody answered should keep
- * polling. Which documents have a feed at all is {@link parseFeedPath}'s to say.
- */
-function comments(c, document) {
-    const { conversation, renderer, config } = c.var;
-    const site = renderer.site();
-    const limit = feedSize(site);
-    // The same reading the page is drawn from, which is the point: a subscriber
-    // to a post's comments and a reader who scrolls to the bottom of it are
-    // looking at one conversation. A post's own feed hands the builder entries
-    // with no post attached, and so its items name no post: there, every item
-    // answers the same one.
-    const found = feedComments(document === undefined ? conversation.latest(limit) : spokenIn(conversation.thread(document)), {
-        baseUrl: config.baseUrl,
-        limit,
-        cited: (url) => c.var.replyContexts.read(url),
-        post: document,
-    });
-    const source = {
-        site,
-        comments: found,
-        title: document === undefined
-            ? `${site.title}: comments`
-            : `${COMMENTS_TITLE_PREFIX}${postLabel(document, (url) => c.var.replyContexts.read(url))}`,
-        href: document?.permalink ?? '/',
-        feedHref: commentsFeedHref(document),
-        baseUrl: config.baseUrl,
-    };
-    return commentsFeedResponse(source, conditionalHeaders(c));
-}
-/**
- * The feed of one item's direct replies (TASK-324): a post's or page's, or a
- * reply's, so a reader can walk a thread one level at a time through
- * `source:comments`. An item nobody answered has an empty feed; a segment
- * naming nothing a reader can see 404s, as does one on a document not showing
- * its conversation, by the rule `{permalink}feed/` follows.
- */
-function repliesFeed(c, segment) {
-    const { conversation, renderer, config } = c.var;
-    const found = conversation.repliesTo(segment);
-    if (found === undefined || !showsConversation(c, found.post))
-        return notFound(c);
-    const site = renderer.site();
-    const cited = (url) => c.var.replyContexts.read(url);
-    const label = postLabel(found.post, cited);
-    const source = {
-        site,
-        comments: feedComments(found.replies, {
-            baseUrl: config.baseUrl,
-            limit: feedSize(site),
-            cited,
-            post: found.post,
-        }),
-        title: found.reply === null
-            ? `Replies to: ${label}`
-            : `Replies to ${found.reply.author.name} on ${label}`,
-        href: found.reply?.url ?? found.post.permalink,
-        feedHref: repliesFeedPath(segment),
-        baseUrl: config.baseUrl,
-    };
-    return commentsFeedResponse(source, conditionalHeaders(c));
-}
-/**
- * One native comment on a page of its own (TASK-318), answering as its post
- * would: 410 once the post is deleted, and 404 while it is not served or not
- * showing its conversation. It is never listed anywhere, so it is noindex.
- */
-function commentPage(c, id) {
-    const { conversation, renderer, store } = c.var;
-    const found = conversation.comment(id);
-    if (found === undefined)
-        return notFound(c);
-    const now = store.now();
-    if (isGone(found.post, now))
-        return gone(c);
-    if (!isServed(found.post, now) || !showsConversation(c, found.post))
-        return notFound(c);
-    return c.html(renderer.renderComment(found), 200, { 'x-robots-tag': 'noindex' });
-}
-/**
- * The sitemap, or one of its children once the site is too big for one file.
- *
- * A child that does not exist 404s through the theme like any other missing
- * URL: `/sitemap-1.xml` names nothing at all on a site whose whole sitemap
- * fits, and a crawler asking for one should be told so rather than handed an
- * empty file it would come back to.
- */
-function sitemap(c, page) {
-    const response = sitemapResponse({
-        urls: sitemapUrls(c),
-        baseUrl: c.var.config.baseUrl,
-        page,
-        conditional: conditionalHeaders(c),
-    });
-    return response ?? notFound(c);
-}
-/**
- * Every URL the public site publishes, in the order the sitemap lists them:
- * the home archive's pages, then every post and page, then every tag archive
- * and every category archive with their own pages.
- *
- * Everything here is spelled by the same functions the site's own links go
- * through — {@link homeHref}, the permalinks, {@link termHref} — and drawn
- * from the same queries the listings use, so a sitemap can never advertise a
- * URL the site does not serve. Nothing hidden reaches it either: the index's
- * listing queries already exclude drafts, the trash, posts whose date has not
- * arrived and unlisted documents, and {@link isListed} is asked again with the
- * store's own clock so the two answers cannot drift apart.
- */
-function sitemapUrls(c) {
-    const { store, renderer } = c.var;
-    const now = store.now();
-    const size = renderer.pageSize();
-    const bases = renderer.taxonomyBases();
-    const pages = frontPages(c);
-    const urls = [];
-    /** The pages of one listing, each dated by the newest document on it. */
-    const listingPages = (documents, hrefForPage) => {
-        const totalPages = Math.max(1, Math.ceil(documents.length / size));
-        for (let index = 0; index < totalPages; index += 1) {
-            const onPage = documents.slice(index * size, (index + 1) * size);
-            urls.push({ loc: hrefForPage(index), lastmod: latestModified(onPage) });
-        }
-    };
-    const posts = store.listPosts().filter((document) => isListed(document, now));
-    // The listing's pages, wherever it lives: under `/`, under the posts page,
-    // or nowhere at all on a site whose homepage is a page and which named no
-    // posts page. Its first page is that root, which is why `/` and the posts
-    // page's own URL are listed here rather than with the documents.
-    const root = listingRoot(pages);
-    if (root !== undefined)
-        listingPages(posts, (index) => listingPageHref(root, index));
-    // And `/` itself when it is a page rather than the listing: the front page
-    // is published at one URL, and it is this one.
-    if (pages.home !== undefined)
-        urls.push({ loc: '/', lastmod: lastModifiedOf(pages.home) });
-    const documents = store
-        .listAll({ type: 'page', draft: false, trashed: false, scheduled: false })
-        .filter((document) => isListed(document, now));
-    for (const document of [...posts, ...documents]) {
-        // The homepage answers at `/` and redirects from its own permalink, and
-        // the posts page is the listing's first page, which is already listed:
-        // neither is advertised twice.
-        if (document.path === pages.home?.path || document.path === pages.posts?.path)
-            continue;
-        urls.push({ loc: document.permalink, lastmod: lastModifiedOf(document) });
-    }
-    // A taxonomy archive exists only while something public carries the term,
-    // which is exactly what these two queries report.
-    for (const { tag } of store.listTags()) {
-        const term = { taxonomy: 'tag', term: tag };
-        listingPages(store.listByTag(tag), (index) => termHref(term, index, bases));
-    }
-    for (const { category } of store.listCategories()) {
-        const term = { taxonomy: 'category', term: category };
-        listingPages(store.listByCategory(category), (index) => termHref(term, index, bases));
-    }
-    return urls;
-}
-/**
- * What a generated `/llms.txt` lists: every public page by title, then the
- * posts the feeds carry, newest first, each linked to its Markdown.
- *
- * The homepage is listed at `/`, which is where it is published; its own
- * permalink redirects there.
- */
-function llmsIndex(c) {
-    const { store, renderer } = c.var;
-    const site = renderer.site();
-    const now = store.now();
-    const home = frontPages(c).home;
-    const entry = (document) => llmsEntry(c, document, home);
-    const pages = store
-        .listAll({ type: 'page', draft: false, trashed: false, scheduled: false })
-        .filter((document) => isListed(document, now))
-        .sort((a, b) => llmsLabel(c, a).localeCompare(llmsLabel(c, b)));
-    const posts = store
-        .listPosts({ limit: feedSize(site) })
-        .filter((document) => isListed(document, now));
-    return {
-        title: site.title,
-        description: site.tagline ?? '',
-        pages: pages.map(entry),
-        posts: posts.map(entry),
-    };
-}
-function llmsLabel(c, document) {
-    return postLabel(document, (url) => c.var.replyContexts.read(url));
-}
-function llmsEntry(c, document, home) {
-    return {
-        title: llmsLabel(c, document),
-        href: representationHref(document.path === home?.path ? '/' : encodePath(document.permalink), 'markdown'),
-        description: document.description,
-        lastModified: lastModifiedOf(document),
-    };
-}
-/**
- * A file from the theme's `static/` directory, the site's copy first.
- *
- * Assets are cacheable and validated, so a browser that already has one pays a
- * conditional request rather than a download. A URL whose `v` is the hash of
- * the bytes being served, which is what the `asset` filter writes, is cached
- * for a year without revalidation. Any other `v`, or none, gets the short
- * lifetime: a stale hash from a cached page still gets the file, but the
- * current bytes are never pinned under a name that describes older ones.
- */
-function themeAsset(c) {
-    const relative = requestPath(c).slice(THEME_ASSET_PREFIX.length);
-    const asset = findThemeAsset(relative, c.var.renderer.themeDirs());
-    if (asset === undefined)
-        return notFound(c);
-    const fingerprinted = c.req.query(ASSET_VERSION_PARAM) === assetVersion(asset);
-    const options = fingerprinted ? IMMUTABLE_ASSET : {};
-    return matchesEtag(c.req.header('if-none-match'), asset.etag)
-        ? assetNotModified(asset, options)
-        : assetResponse(asset, options);
-}
-/**
- * One derived copy of an upload, generated on the spot if it is not there.
- *
- * The directory these live in is disposable (decision-9): deleting it costs
- * the next reader of each picture one encode and costs the site nothing else,
- * which is what this handler is for. A width or a format the site does not
- * offer is a 404 and encodes nothing, so the URL space cannot be used to make
- * the server work.
- *
- * A variant is cached for a year without revalidation only when its `v` is
- * the hash of the upload it was derived from, which is what the page markup
- * and the icon links write. The name alone cannot promise that: deleting an
- * upload frees its name for different bytes. Any other `v`, or none, as in a
- * page cached before URLs carried one, still gets the file, for a day.
- */
-async function imageVariant(c) {
-    const relative = decodeVariantPath(requestPath(c).slice(VARIANT_ASSET_PREFIX.length));
-    const asset = await findImageVariant(c.var.config, relative);
-    if (asset === undefined)
-        return notFound(c);
-    const source = relative.slice(0, relative.lastIndexOf('/'));
-    const version = sourceVersion(c.var.config, source);
-    const fingerprinted = version !== undefined && c.req.query(ASSET_VERSION_PARAM) === version;
-    const options = fingerprinted ? IMMUTABLE_ASSET : { maxAge: UPLOAD_ASSET_MAX_AGE };
-    return matchesEtag(c.req.header('if-none-match'), asset.etag)
-        ? assetNotModified(asset, options)
-        : assetResponse(asset, options);
-}
-/**
- * `/favicon.ico`, derived from the site's icon beside its other icons.
- *
- * Its URL carries no version, so it is cached like an upload rather than for
- * a year: a site that changes its icon is seen with the new one within a day.
- */
-async function favicon(c) {
-    const source = siteIconSource(c.var.config, iconSetting(c.var.renderer.site()));
-    if (source === undefined)
-        return notFound(c);
-    const asset = await findImageVariant(c.var.config, `${source}/${FAVICON_FILE}`);
-    if (asset === undefined)
-        return notFound(c);
-    const options = { maxAge: UPLOAD_ASSET_MAX_AGE };
-    return matchesEtag(c.req.header('if-none-match'), asset.etag)
-        ? assetNotModified(asset, options)
-        : assetResponse(asset, options);
-}
-/** A request path as a path on disk: percent-encoding off, segment by segment. */
-function decodeVariantPath(relative) {
-    try {
-        return relative.split('/').map(decodeURIComponent).join('/');
-    }
-    catch {
-        return relative;
-    }
-}
-/**
- * A file from `content/uploads/`, at the URL Eleventy's passthrough copy puts
- * it at.
- *
- * Uploads are not documents — the index never sees them — so they are served
- * as files, with the same validators and the same traversal check the theme's
- * assets get. The cache lifetime is longer than a theme asset's because an
- * upload's URL names one set of bytes: the upload endpoint never overwrites,
- * it suffixes.
- */
-function upload(c) {
-    const relative = requestPath(c).slice(UPLOAD_ASSET_PREFIX.length);
-    const asset = findUpload(relative, c.var.config.contentDir);
-    if (asset === undefined)
-        return notFound(c);
-    const options = { maxAge: UPLOAD_ASSET_MAX_AGE };
-    if (matchesEtag(c.req.header('if-none-match'), asset.etag)) {
-        return assetNotModified(asset, options);
-    }
-    const part = assetRangeResponse(asset, c.req.header('range'), c.req.header('if-range'), options);
-    const whole = part ?? assetResponse(asset, options);
-    whole.headers.set('accept-ranges', 'bytes');
-    return whole;
-}
-/** The URL of a page of the home listing, by zero-based index. */
-export function homeHref(index) {
-    return listingPageHref('/', index);
-}
-/**
- * The URL of a page of the listing that hangs off `root`, by zero-based index.
- *
- * The first page is the root itself: `/` or the posts page's own permalink,
- * which is what makes a posts page one URL rather than two.
- */
-export function listingPageHref(root, index) {
-    return index === 0 ? root : `${root}${PAGE_SEGMENT}/${String(index + 1)}/`;
-}
-/**
- * What the theme is told about a taxonomy archive: the term under the name of
- * its taxonomy, and the layout that taxonomy uses.
- */
-function taxonomyContext(term) {
-    return term.taxonomy === 'tag'
-        ? { tag: term.term, template: TEMPLATES.tag }
-        : { category: term.term, template: TEMPLATES.category };
-}
-/**
- * What the theme is told about an author archive: the person's profile under
- * `author`, the same shape a post's byline gets, and the layout an archive of
- * theirs uses.
- *
- * One shape for both places is the point. A theme that knows how to print a
- * byline already knows how to print the heading of the archive that byline
- * links to, and neither has to ask whether the site has users.
- */
-function authorArchiveContext(author) {
-    return { author: profileContext(author.user), template: TEMPLATES.author };
-}
-/**
- * The URL of a feed: the whole site's, or one taxonomy archive's.
- *
- * WordPress's layout, so a subscriber of a migrated site keeps polling the URL
- * they already hold: `/feed/` is RSS 2.0, `/feed/atom/` and `/feed/json/` are
- * its siblings, and an archive's feeds hang off the archive.
- */
-export function feedHref(term, format, bases) {
-    return feedPathUnder(listingHref({ term }, 0, bases), format);
-}
-/**
- * Where the site's comments feed lives, and where one document's does.
- *
- * WordPress's URLs, so a site migrated from it keeps both: the whole site's
- * comments at `/comments/feed/`, and a document's under its own permalink. There
- * is one format, RSS 2.0, because that is what a comments feed is read in.
- */
-export function commentsFeedHref(document) {
-    return commentsFeedPath(document === undefined ? undefined : encodePath(document.permalink));
-}
-function gone(c) {
-    return c.html(c.var.renderer.renderGone(requestPath(c)), 410);
-}
-/** The theme's 404 page. */
-export function notFound(c) {
-    return c.html(c.var.renderer.renderNotFound(requestPath(c)), 404);
-}
-/**
- * The requested path, percent-decoded, because permalinks are stored decoded.
- * A path whose escapes are malformed is used as it arrived, which resolves to
- * nothing and so 404s.
- */
-export function requestPath(c) {
-    const { pathname } = new URL(c.req.url);
-    try {
-        return decodeURIComponent(pathname);
-    }
-    catch {
-        return pathname;
-    }
-}
-/** A decoded path back into one safe to put in a `Location` header. */
-function encodePath(pathname) {
-    return pathname
-        .split('/')
-        .map((segment) => encodeURIComponent(segment))
-        .join('/');
+        ? termHref(moved, asked.pageNumber, view.bases)
+        : feedHref(moved, feedPath.format, view.bases);
 }
 //# sourceMappingURL=routes.js.map