@jant/core 0.3.39 → 1.0.0

package/src/routes/pages/archive.tsx

@@ -4,11 +4,16 @@
  * Tumblr-style archive grid with rich filtering:
  * year, collection, format, media types, title presence.
  * Page-based pagination with media-enriched thread-root tiles.
+ *
+ * Also serves a filtered Atom feed at /archive/feed.
  */
 
+import { msg } from "@lingui/core/macro";
 import { Hono } from "hono";
+import type { Context } from "hono";
 import type {
   Bindings,
+  FeedData,
   Format,
   MediaKind,
   PostWithMedia,
@@ -21,39 +26,68 @@ import type {
 } from "../../types/props.js";
 import { FORMATS, MEDIA_KINDS } from "../../types.js";
 import { ArchivePage } from "../../ui/pages/ArchivePage.js";
+import { defaultFeedRenderer } from "../../lib/feed.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { buildPageTitle } from "../../lib/page-title.js";
 import { renderPublicPage } from "../../lib/render.js";
-import { formatYearMonth } from "../../lib/time.js";
+import { formatYearMonth, toISOString } from "../../lib/time.js";
+import { toAbsoluteSiteUrl, toPublicPath } from "../../lib/url.js";
 import {
   createMediaContext,
   toArchiveGroupsWithMedia,
+  toPostViews,
 } from "../../lib/view.js";
 import { buildMediaMap } from "../../lib/media-helpers.js";
 import { assembleTimelineItems } from "../../lib/timeline.js";
+import { getI18n } from "../../i18n/index.js";
 import type { PostFilters } from "../../services/post.js";
+import { toPlainText } from "../../lib/markdown.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
-export const archiveRoutes = new Hono<Env>();
-
-archiveRoutes.get("/", async (c) => {
-  const { services, appConfig } = c.var;
-  const pageSize = appConfig.archivePageSize;
+// =============================================================================
+// Shared filter parsing
+// =============================================================================
+
+/** Parsed archive query parameters (before service-level filter conversion). */
+interface ParsedArchiveParams {
+  format?: Format;
+  validYear?: number;
+  collectionSlug?: string;
+  mediaKinds?: MediaKind[];
+  hasMedia?: boolean;
+  hasTitle?: boolean;
+  visibility?: ArchiveVisibility;
+  visibilityAll: boolean;
+  view?: ArchiveView;
+  currentPage: number;
+}
 
-  // --- Parse query params ---------------------------------------------------
-
-  const formatParam = c.req.query("format") as Format | undefined;
+/**
+ * Parse archive filter query parameters.
+ *
+ * @param c - Hono context
+ * @param queryOverrides - Optional map of query param overrides (used by custom archive URLs)
+ * @returns Parsed and validated query parameters
+ */
+function parseArchiveParams(
+  c: Context<Env>,
+  queryOverrides?: Record<string, string>,
+): ParsedArchiveParams {
+  const q = (key: string): string | undefined =>
+    queryOverrides ? queryOverrides[key] : c.req.query(key);
+
+  const formatParam = q("format") as Format | undefined;
   const format =
     formatParam && FORMATS.includes(formatParam) ? formatParam : undefined;
 
-  const yearParam = c.req.query("year");
+  const yearParam = q("year");
   const year = yearParam ? parseInt(yearParam, 10) : undefined;
   const validYear = year && !isNaN(year) && year > 1970 ? year : undefined;
 
-  const collectionSlug = c.req.query("collection") || undefined;
+  const collectionSlug = q("collection") || undefined;
 
-  const mediaParam = c.req.query("media") || undefined;
+  const mediaParam = q("media") || undefined;
   const mediaKinds = mediaParam
     ? (mediaParam
         .split(",")
@@ -62,68 +96,83 @@ archiveRoutes.get("/", async (c) => {
         ) as MediaKind[])
     : undefined;
 
-  const hasMediaParam = c.req.query("hasMedia");
+  const hasMediaParam = q("hasMedia");
   const hasMedia =
     hasMediaParam === "1" ? true : hasMediaParam === "0" ? false : undefined;
 
-  const hasTitleParam = c.req.query("hasTitle");
+  const hasTitleParam = q("hasTitle");
   const hasTitle =
     hasTitleParam === "1" ? true : hasTitleParam === "0" ? false : undefined;
 
   const VALID_VISIBILITIES = ["public", "latest_hidden", "private", "featured"];
-  const visibilityParam = c.req.query("visibility");
+  const visibilityParam = q("visibility");
   const visibilityAll = visibilityParam === "all";
   const visibility =
     visibilityParam && VALID_VISIBILITIES.includes(visibilityParam)
       ? (visibilityParam as ArchiveVisibility)
       : undefined;
 
-  const viewParam = c.req.query("view") as ArchiveView | undefined;
+  const viewParam = q("view") as ArchiveView | undefined;
   const view =
     viewParam && (viewParam === "grid" || viewParam === "list")
       ? viewParam
       : undefined;
 
+  // Page always comes from the actual request URL (pagination links use ?page=N)
   const pageParam = c.req.query("page");
   const currentPage = Math.max(1, parseInt(pageParam || "1", 10) || 1);
 
-  // --- Resolve collection slug to ID ----------------------------------------
+  return {
+    format,
+    validYear,
+    collectionSlug,
+    mediaKinds: mediaKinds && mediaKinds.length > 0 ? mediaKinds : undefined,
+    hasMedia,
+    hasTitle,
+    visibility,
+    visibilityAll,
+    view,
+    currentPage,
+  };
+}
 
-  const collection = collectionSlug
-    ? await services.collections.getBySlug(collectionSlug)
+/**
+ * Build PostFilters from parsed archive params.
+ *
+ * @param params - Parsed query params
+ * @param opts - Auth & collection context
+ * @returns PostFilters for the post service
+ */
+function buildArchivePostFilters(
+  params: ParsedArchiveParams,
+  opts: {
+    isAuthenticated: boolean;
+    collectionId?: string;
+  },
+): PostFilters {
+  const { isAuthenticated, collectionId } = opts;
+
+  // Map visibility: feed routes force public; page respects auth
+  // Authenticated users default to showing all visibilities
+  const effectiveVisibility = isAuthenticated
+    ? params.visibilityAll
+      ? undefined
+      : (params.visibility ?? undefined)
     : undefined;
-  const collectionId = collection?.id;
-
-  // --- Build timestamp range for year filter --------------------------------
 
   let publishedAfter: number | undefined;
   let publishedBefore: number | undefined;
-  if (validYear) {
-    publishedAfter = Date.UTC(validYear, 0, 1) / 1000;
-    publishedBefore = Date.UTC(validYear + 1, 0, 1) / 1000;
+  if (params.validYear) {
+    publishedAfter = Date.UTC(params.validYear, 0, 1) / 1000;
+    publishedBefore = Date.UTC(params.validYear + 1, 0, 1) / 1000;
   }
 
-  // --- Build filters --------------------------------------------------------
-
-  const navData = await getNavigationData(c);
-
-  // --- Map visibility filter to service-level filters -------------------------
-  // Visibility filter is only meaningful when authenticated — unauthenticated
-  // users cannot see latest_hidden or private posts regardless of the query param.
-
-  // Default to "public" when authenticated unless explicitly set to "all"
-  const effectiveVisibility = navData.isAuthenticated
-    ? visibilityAll
-      ? undefined
-      : (visibility ?? "public")
-    : undefined;
-
-  const filters: PostFilters = {
-    format,
+  return {
+    format: params.format,
     status: "published",
     excludeReplies: true,
-    excludePrivate: !navData.isAuthenticated,
-    excludeLatestHidden: !navData.isAuthenticated,
+    excludePrivate: !isAuthenticated,
+    excludeLatestHidden: false,
     ...(effectiveVisibility === "featured"
       ? { featured: true }
       : effectiveVisibility
@@ -132,21 +181,84 @@ archiveRoutes.get("/", async (c) => {
     collectionId,
     publishedAfter,
     publishedBefore,
-    mediaKinds: mediaKinds && mediaKinds.length > 0 ? mediaKinds : undefined,
-    hasMedia,
-    hasTitle,
+    mediaKinds: params.mediaKinds,
+    hasMedia: params.hasMedia,
+    hasTitle: params.hasTitle,
   };
+}
+
+/**
+ * Build a query string from parsed archive params (for feed self-URL and
+ * archive page feed link). Omits page-only params (view, page).
+ */
+function buildArchiveFeedQuery(params: ParsedArchiveParams): string {
+  const qs = new URLSearchParams();
+  if (params.format) qs.set("format", params.format);
+  if (params.validYear) qs.set("year", String(params.validYear));
+  if (params.collectionSlug) qs.set("collection", params.collectionSlug);
+  if (params.mediaKinds && params.mediaKinds.length > 0) {
+    qs.set("media", params.mediaKinds.join(","));
+  }
+  if (params.hasMedia !== undefined) {
+    qs.set("hasMedia", params.hasMedia ? "1" : "0");
+  }
+  if (params.hasTitle !== undefined) {
+    qs.set("hasTitle", params.hasTitle ? "1" : "0");
+  }
+  const str = qs.toString();
+  return str ? `?${str}` : "";
+}
+
+export const archiveRoutes = new Hono<Env>();
+
+// =============================================================================
+// Archive page — shared rendering
+// =============================================================================
+
+/**
+ * Render the archive page. Used by both the `/archive` route and custom
+ * archive URLs resolved through the path registry.
+ *
+ * @param c - Hono context
+ * @param queryOverrides - Optional pre-set query params (from path_registry.archive_query)
+ */
+export async function renderArchivePage(
+  c: Context<Env>,
+  queryOverrides?: Record<string, string>,
+): Promise<Response> {
+  const { services, appConfig } = c.var;
+  const pageSize = appConfig.archivePageSize;
+  const params = parseArchiveParams(c, queryOverrides);
+
+  // --- Resolve collection slug to ID ----------------------------------------
+
+  const collection = params.collectionSlug
+    ? await services.collections.getBySlug(params.collectionSlug)
+    : undefined;
+  const collectionId = collection?.id;
+
+  const navData = await getNavigationData(c);
+
+  const filters = buildArchivePostFilters(params, {
+    isAuthenticated: navData.isAuthenticated,
+    collectionId,
+  });
 
   // --- Parallel data fetches ------------------------------------------------
+  // List view doesn't need month-based grouping, so skip countByYearMonth.
+
+  const isListView = params.view === "list";
 
   const [totalCount, monthlyCounts, posts, availableYears, allCollections] =
     await Promise.all([
       services.posts.count(filters),
-      services.posts.countByYearMonth(filters),
+      isListView
+        ? Promise.resolve([] as { yearMonth: string; count: number }[])
+        : services.posts.countByYearMonth(filters),
       services.posts.list({
         ...filters,
         limit: pageSize,
-        offset: (currentPage - 1) * pageSize,
+        offset: (params.currentPage - 1) * pageSize,
       }),
       services.posts.getDistinctYears({
         status: "published",
@@ -157,94 +269,103 @@ archiveRoutes.get("/", async (c) => {
 
   const totalPages = Math.max(1, Math.ceil(totalCount / pageSize));
 
-  // --- Group posts by year-month --------------------------------------------
+  const mediaCtx = createMediaContext(appConfig);
+  const allPostIds = posts.map((p) => p.id);
+  const archiveAliasesMap =
+    await c.var.services.paths.getPostAliases(allPostIds);
+  const archiveAliasMap = new Map<string, string>();
+  for (const [id, aliases] of archiveAliasesMap) {
+    if (aliases[0]) archiveAliasMap.set(id, aliases[0]);
+  }
 
-  const grouped = new Map<string, PostWithMedia[]>();
-  for (const post of posts) {
-    const publishedAt = post.publishedAt ?? post.updatedAt;
-    const key = formatYearMonth(publishedAt, appConfig.timeZone);
-    if (!grouped.has(key)) {
-      grouped.set(key, []);
+  // --- List view: flat timeline items (no month grouping) ------------------
+
+  let groups: Awaited<ReturnType<typeof toArchiveGroupsWithMedia>> = [];
+  let flatItems: Awaited<ReturnType<typeof assembleTimelineItems>> | undefined;
+
+  if (isListView) {
+    flatItems = await assembleTimelineItems(c, posts);
+  } else {
+    // --- Grid view: group posts by year-month --------------------------------
+
+    const grouped = new Map<string, PostWithMedia[]>();
+    for (const post of posts) {
+      const publishedAt = post.publishedAt ?? post.updatedAt;
+      const key = formatYearMonth(publishedAt, appConfig.timeZone);
+      if (!grouped.has(key)) {
+        grouped.set(key, []);
+      }
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Map.set() above guarantees key exists
+      grouped.get(key)!.push({
+        ...post,
+        mediaAttachments: [],
+      });
     }
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Map.set() above guarantees key exists
-    grouped.get(key)!.push({
-      ...post,
-      mediaAttachments: [],
-    });
-  }
 
-  const monthlyCountMap = new Map(
-    monthlyCounts.map((row) => [row.yearMonth, row.count] as const),
-  );
-  const mediaCtx = createMediaContext(appConfig);
-  const groups =
-    view === "list"
-      ? await (async () => {
-          const items = await assembleTimelineItems(c, posts);
-          const itemsById = new Map(items.map((item) => [item.post.id, item]));
-
-          return toArchiveGroupsWithMedia(grouped, mediaCtx).map((group) => ({
-            ...group,
-            posts: [],
-            items: group.posts
-              .map((post) => itemsById.get(post.id))
-              .filter((item): item is NonNullable<typeof item> => !!item),
-            totalCount:
-              monthlyCountMap.get(`${group.year}-${group.month}`) ??
-              group.posts.length,
-          }));
-        })()
-      : await (async () => {
-          const postIds = posts.map((p) => p.id);
-          const [rawMediaMap, replyCounts] = await Promise.all([
-            services.media.getByPostIds(postIds),
-            services.posts.getReplyCounts(postIds),
-          ]);
-          const mediaMap = buildMediaMap(
-            rawMediaMap,
-            mediaCtx.r2PublicUrl,
-            mediaCtx.imageTransformUrl,
-            mediaCtx.s3PublicUrl,
-            mediaCtx.localPublicUrl,
-            mediaCtx.sitePathPrefix,
-          );
-
-          for (const [key, monthPosts] of grouped) {
-            grouped.set(
-              key,
-              monthPosts.map((post) => ({
-                ...post,
-                mediaAttachments: mediaMap.get(post.id) ?? [],
-              })),
-            );
-          }
-
-          return toArchiveGroupsWithMedia(grouped, mediaCtx).map((group) => ({
-            ...group,
-            posts: group.posts.map((post) => ({
-              ...post,
-              replyCount: replyCounts.get(post.id) ?? undefined,
-            })),
-            totalCount:
-              monthlyCountMap.get(`${group.year}-${group.month}`) ??
-              group.posts.length,
-          }));
-        })();
+    const monthlyCountMap = new Map(
+      monthlyCounts.map((row) => [row.yearMonth, row.count] as const),
+    );
+
+    const postIds = posts.map((p) => p.id);
+    const [rawMediaMap, replyCounts] = await Promise.all([
+      services.media.getByPostIds(postIds),
+      services.posts.getReplyCounts(postIds),
+    ]);
+    const mediaMap = buildMediaMap(
+      rawMediaMap,
+      mediaCtx.r2PublicUrl,
+      mediaCtx.imageTransformUrl,
+      mediaCtx.s3PublicUrl,
+      mediaCtx.localPublicUrl,
+      mediaCtx.sitePathPrefix,
+    );
+
+    for (const [key, monthPosts] of grouped) {
+      grouped.set(
+        key,
+        monthPosts.map((post) => ({
+          ...post,
+          mediaAttachments: mediaMap.get(post.id) ?? [],
+        })),
+      );
+    }
+
+    groups = toArchiveGroupsWithMedia(grouped, mediaCtx, archiveAliasMap).map(
+      (group) => ({
+        ...group,
+        posts: group.posts.map((post) => ({
+          ...post,
+          replyCount: replyCounts.get(post.id) ?? undefined,
+        })),
+        totalCount:
+          monthlyCountMap.get(`${group.year}-${group.month}`) ??
+          group.posts.length,
+      }),
+    );
+  }
 
   // --- Build active filter state for UI -------------------------------------
 
+  const effectiveVisibility = navData.isAuthenticated
+    ? params.visibilityAll
+      ? undefined
+      : (params.visibility ?? undefined)
+    : undefined;
+
   const archiveFilters: ArchiveFilters = {
-    year: validYear,
-    collectionSlug,
+    year: params.validYear,
+    collectionSlug: params.collectionSlug,
     collectionTitle: collection?.title,
-    format,
-    mediaKinds: mediaKinds && mediaKinds.length > 0 ? mediaKinds : undefined,
-    hasMedia,
-    hasTitle,
+    format: params.format,
+    mediaKinds: params.mediaKinds,
+    hasMedia: params.hasMedia,
+    hasTitle: params.hasTitle,
     visibility: effectiveVisibility,
-    view,
+    view: params.view,
   };
 
+  const feedQuery = buildArchiveFeedQuery(params);
+
   const availableCollectionsList = allCollections.map((col) => ({
     slug: col.slug,
     title: col.title,
@@ -256,8 +377,9 @@ archiveRoutes.get("/", async (c) => {
     content: (
       <ArchivePage
         groups={groups}
+        items={flatItems}
         totalCount={totalCount}
-        currentPage={currentPage}
+        currentPage={params.currentPage}
         totalPages={totalPages}
         filters={archiveFilters}
         availableYears={availableYears}
@@ -265,7 +387,281 @@ archiveRoutes.get("/", async (c) => {
         isAuthenticated={navData.isAuthenticated}
         sitePathPrefix={navData.sitePathPrefix}
         timeZone={appConfig.timeZone}
+        feedHref={`/archive/feed${feedQuery}`}
       />
     ),
   });
+}
+
+// =============================================================================
+// Archive page route
+// =============================================================================
+
+archiveRoutes.get("/", (c) => renderArchivePage(c));
+
+// =============================================================================
+// Archive feed
+// =============================================================================
+
+/**
+ * Build a descriptive feed title from active filters.
+ *
+ * @param c - Hono context
+ * @param params - Parsed archive filter params
+ * @param collectionTitle - Resolved collection title (if any)
+ * @returns Feed title string, e.g. "Site - Archive: Notes without title"
+ */
+function buildArchiveFeedTitle(
+  c: Context<Env>,
+  params: ParsedArchiveParams,
+  collectionTitle?: string,
+): string {
+  const i18n = getI18n(c);
+  const siteName = c.var.appConfig.siteName;
+
+  const parts: string[] = [];
+
+  if (params.format) {
+    const formatLabels: Record<string, string> = {
+      note: i18n._(
+        msg({
+          message: "Notes",
+          comment:
+            "@context: Archive feed title segment for note format filter",
+        }),
+      ),
+      link: i18n._(
+        msg({
+          message: "Links",
+          comment:
+            "@context: Archive feed title segment for link format filter",
+        }),
+      ),
+      quote: i18n._(
+        msg({
+          message: "Quotes",
+          comment:
+            "@context: Archive feed title segment for quote format filter",
+        }),
+      ),
+    };
+    parts.push(formatLabels[params.format] ?? params.format);
+  }
+
+  if (collectionTitle) {
+    parts.push(collectionTitle);
+  }
+
+  if (params.hasTitle === false) {
+    parts.push(
+      i18n._(
+        msg({
+          message: "without title",
+          comment: "@context: Archive feed title segment for hasTitle=0 filter",
+        }),
+      ),
+    );
+  } else if (params.hasTitle === true) {
+    parts.push(
+      i18n._(
+        msg({
+          message: "with title",
+          comment: "@context: Archive feed title segment for hasTitle=1 filter",
+        }),
+      ),
+    );
+  }
+
+  if (params.hasMedia === true) {
+    parts.push(
+      i18n._(
+        msg({
+          message: "with media",
+          comment: "@context: Archive feed title segment for hasMedia=1 filter",
+        }),
+      ),
+    );
+  } else if (params.hasMedia === false) {
+    parts.push(
+      i18n._(
+        msg({
+          message: "without media",
+          comment: "@context: Archive feed title segment for hasMedia=0 filter",
+        }),
+      ),
+    );
+  }
+
+  if (params.validYear) {
+    parts.push(String(params.validYear));
+  }
+
+  const archiveLabel = i18n._(
+    msg({
+      message: "Archive",
+      comment: "@context: Archive feed title prefix",
+    }),
+  );
+
+  if (parts.length === 0) {
+    return `${siteName} - ${archiveLabel}`;
+  }
+
+  return `${siteName} - ${archiveLabel}: ${parts.join(", ")}`;
+}
+
+async function buildArchiveFeedData(
+  c: Context<Env>,
+  selfPath: string,
+): Promise<FeedData> {
+  const { appConfig, services } = c.var;
+  const params = parseArchiveParams(c);
+
+  const collection = params.collectionSlug
+    ? await services.collections.getBySlug(params.collectionSlug)
+    : undefined;
+
+  // Feed always serves public-only content
+  const filters: PostFilters = {
+    format: params.format,
+    status: "published",
+    excludeReplies: true,
+    excludePrivate: true,
+    excludeLatestHidden: true,
+    collectionId: collection?.id,
+    mediaKinds: params.mediaKinds,
+    hasMedia: params.hasMedia,
+    hasTitle: params.hasTitle,
+    ...(params.validYear
+      ? {
+          publishedAfter: Date.UTC(params.validYear, 0, 1) / 1000,
+          publishedBefore: Date.UTC(params.validYear + 1, 0, 1) / 1000,
+        }
+      : {}),
+    limit: appConfig.rssFeedLimit,
+  };
+
+  const posts = await services.posts.list(filters);
+
+  // Collect thread root IDs to batch-load replies
+  const rootIds = posts.filter((p) => p.threadId === p.id).map((p) => p.id);
+
+  // Batch load media, aliases, and thread replies
+  const postIds = posts.map((p) => p.id);
+  const [threadMap, rawMediaMap, aliasesMap] = await Promise.all([
+    services.posts.getPublishedThreads(rootIds),
+    services.media.getByPostIds(postIds),
+    services.paths.getPostAliases(postIds),
+  ]);
+
+  // Collect reply IDs for media loading
+  const replyIds: string[] = [];
+  for (const [rootId, thread] of threadMap) {
+    for (const reply of thread) {
+      if (reply.id !== rootId) {
+        replyIds.push(reply.id);
+      }
+    }
+  }
+
+  const replyMediaMap =
+    replyIds.length > 0
+      ? await services.media.getByPostIds(replyIds)
+      : new Map<
+          string,
+          typeof rawMediaMap extends Map<string, infer V> ? V : never
+        >();
+
+  const mediaCtx = createMediaContext(appConfig);
+
+  // Merge all media
+  const allRawMedia = new Map(rawMediaMap);
+  for (const [id, media] of replyMediaMap) {
+    allRawMedia.set(id, media);
+  }
+
+  const mediaMap = buildMediaMap(
+    allRawMedia,
+    mediaCtx.r2PublicUrl,
+    mediaCtx.imageTransformUrl,
+    mediaCtx.s3PublicUrl,
+    mediaCtx.localPublicUrl,
+    mediaCtx.sitePathPrefix,
+  );
+  const aliasMap = new Map<string, string>();
+  for (const [id, aliases] of aliasesMap) {
+    if (aliases[0]) aliasMap.set(id, aliases[0]);
+  }
+
+  const postViews = toPostViews(
+    posts.map((p) => ({
+      ...p,
+      mediaAttachments: mediaMap.get(p.id) ?? [],
+    })),
+    mediaCtx,
+    undefined,
+    aliasMap,
+  ).map((postView, index) => {
+    const post = posts[index] as (typeof posts)[number];
+
+    // Build thread replies
+    const thread = threadMap.get(post.id);
+    const replies =
+      thread && thread.length > 1
+        ? toPostViews(
+            thread
+              .filter((r) => r.id !== post.id)
+              .map((r) => ({
+                ...r,
+                mediaAttachments: mediaMap.get(r.id) ?? [],
+              })),
+            mediaCtx,
+          )
+        : undefined;
+
+    return {
+      ...postView,
+      feedUpdatedAt: toISOString(post.lastActivityAt),
+      threadReplies: replies,
+    };
+  });
+
+  const feedQuery = buildArchiveFeedQuery(params);
+
+  return {
+    siteName: appConfig.siteName,
+    siteDescription: toPlainText(appConfig.siteDescription),
+    siteUrl: appConfig.siteUrl,
+    siteLanguage: appConfig.siteLanguage,
+    title: buildArchiveFeedTitle(c, params, collection?.title),
+    selfUrl: toAbsoluteSiteUrl(
+      `${selfPath}${feedQuery}`,
+      appConfig.siteUrl,
+      appConfig.sitePathPrefix,
+    ),
+    posts: postViews,
+  };
+}
+
+// Atom — /archive/feed
+archiveRoutes.get("/feed", async (c) => {
+  const feedData = await buildArchiveFeedData(c, "/archive/feed");
+  return new Response(defaultFeedRenderer(feedData), {
+    headers: {
+      "Content-Type": "application/atom+xml; charset=utf-8",
+      "Cache-Control": "public, max-age=180",
+    },
+  });
+});
+
+// Legacy atom.xml redirect
+archiveRoutes.get("/feed/atom.xml", (c) => {
+  const sitePathPrefix = c.var.appConfig.sitePathPrefix;
+  const qs = c.req.url.includes("?")
+    ? c.req.url.slice(c.req.url.indexOf("?"))
+    : "";
+  return c.redirect(
+    `${toPublicPath("/archive/feed", sitePathPrefix)}${qs}`,
+    308,
+  );
 });