@jant/core 0.6.14 → 0.6.16

package/src/services/post.ts

@@ -20,6 +20,7 @@ import {
   asc,
   lte,
   gt,
+  getTableColumns,
 } from "drizzle-orm";
 import {
   type Database,
@@ -31,14 +32,25 @@ import {
   sqliteSchemaBundle,
   type DatabaseSchema,
 } from "../db/schema-bundle.js";
+import {
+  buildRootActivityExpr,
+  rootActivityColumns,
+} from "../db/thread-activity.js";
 import { createEntityId } from "../lib/ids.js";
 import { now } from "../lib/time.js";
-import { renderTiptapJson, trimTiptapBody } from "../lib/tiptap-render.js";
+import { trimTiptapBody } from "../lib/tiptap-render.js";
+import {
+  POST_BODY_HTML_VERSION,
+  renderPostBodyHtml,
+  resolvePostBodyHtml,
+  tryPreparePostBodyHtml,
+} from "../lib/post-body-html.js";
 import { extractSummary, extractBodyText } from "../lib/summary.js";
 import { markdownToTiptapJson } from "../lib/markdown-to-tiptap.js";
 import { tiptapJsonToMarkdown } from "../lib/tiptap-to-markdown.js";
 import { generatePostSlug } from "../lib/slug.js";
 import { getSlugValidationIssue } from "../lib/slug-format.js";
+import { isReservedPath } from "../lib/constants.js";
 import { normalizePath, slugify } from "../lib/url.js";
 import type { StorageDriver } from "../lib/storage.js";
 import type { MediaService } from "./media.js";
@@ -73,6 +85,9 @@ import {
 } from "../lib/youtube.js";
 import { getPreviewStorageKey } from "../lib/upload.js";
 import { generateRandomId } from "../lib/nanoid.js";
+import { resolveSummaryConfig } from "../lib/resolve-config.js";
+import type { Bindings } from "../types/bindings.js";
+import type { SettingsService } from "./settings.js";
 
 /** Dependencies for operations that coordinate with other services */
 export interface PostDeleteDeps {
@@ -80,6 +95,32 @@ export interface PostDeleteDeps {
   storage?: StorageDriver | null;
 }
 
+export interface RebuildBodyHtmlOptions {
+  /** Batch size (1..100, default 50). */
+  limit?: number;
+  /** Exclusive post ID cursor. */
+  cursor?: string;
+  /** Compute and report changes without writing them. */
+  dryRun?: boolean;
+  /** Summary settings used only when a canonical legacy body is upgraded. */
+  summaryConfig?: SummaryConfig;
+}
+
+export interface RebuildBodyHtmlResult {
+  processed: number;
+  wouldRebuild: number;
+  rebuilt: number;
+  wouldUpgradeFootnotes: number;
+  upgradedFootnotes: number;
+  skipped: number;
+  conflicted: number;
+  failed: number;
+  failures: Array<{ postId: string; error: string }>;
+  nextCursor: string | null;
+  done: boolean;
+  targetVersion: number;
+}
+
 export interface PostAttachmentDeps extends PostDeleteDeps {
   storageDriver: string;
   maxFileSizeMB: number;
@@ -104,6 +145,14 @@ export interface PostFilters {
   publishedAfter?: number;
   /** Unix timestamp (exclusive) — only posts published before this time */
   publishedBefore?: number;
+  /**
+   * Unix timestamp (inclusive) — range filter on whichever column `sortBy`
+   * selects. Kept separate from `publishedAfter` so a caller can pin a
+   * publication window (the RSS delay) and still filter on the sort axis.
+   */
+  axisAfter?: number;
+  /** Unix timestamp (exclusive) — upper bound on the `sortBy` column */
+  axisBefore?: number;
   /** Media kinds to filter by (OR logic: post has media of ANY selected kind). */
   mediaKinds?: MediaKind[];
   /** Filter by media presence */
@@ -119,7 +168,21 @@ export interface PostFilters {
   hasReplies?: boolean;
   /** Explicit result sort order */
   sortOrder?: SortOrder;
-  /** Ignore global pinned ordering when sorting subscription/feed results. */
+  /**
+   * Time axis for chronological queries (defaults to announced activity).
+   *
+   * - `activity` — `lastActivityAt`: last announced post. Quiet replies do not
+   *   move it. Latest and the feeds use this.
+   * - `thread_updated` — `threadUpdatedAt`: last post of any kind, quiet
+   *   included. The archive's updated sort uses this.
+   * - `published` — when the Thread root itself was published.
+   *
+   * Selects the column used for sorting **and** for the year/month bucketing
+   * done by `countByYearMonth` and `getDistinctYears`, so a caller that groups
+   * its results cannot end up with buckets that disagree with the order.
+   */
+  sortBy?: "activity" | "thread_updated" | "published";
+  /** Ignore global pinned ordering when results must remain chronological. */
   ignorePinnedSort?: boolean;
   limit?: number;
   cursor?: string;
@@ -135,6 +198,13 @@ export interface SummaryConfig {
 interface ThreadRootPageOptions {
   status?: Status;
   excludePrivate?: boolean;
+  excludeLatestHidden?: boolean;
+  /** Exclude Posts published at or after this Unix timestamp. */
+  publishedBefore?: number;
+  /** Restrict by the Thread root's format without excluding Child Posts. */
+  rootFormat?: Format;
+  /** Restrict to Threads with at least one rated published post. */
+  hasRating?: true;
   limit?: number;
   offset?: number;
 }
@@ -146,6 +216,8 @@ interface CollectionFeedEntryOptions extends ThreadRootPageOptions {
 
 interface CollectionThreadRootPageOptions extends ThreadRootPageOptions {
   sortOrder?: CollectionSortOrder;
+  /** Root Post ID returned by the previous page. */
+  cursor?: string;
 }
 
 interface CursorSortKey {
@@ -159,6 +231,24 @@ export interface CollectionFeedEntry {
   collectedAt: number;
 }
 
+export interface FeaturedThreadTimelinePost {
+  post: Post;
+  /** Zero-based position among the Thread's published Posts. */
+  position: number;
+}
+
+/**
+ * Bounded projection for one curated Featured Thread.
+ *
+ * `posts` contains only the Root, every Featured Post, and the final published
+ * Post, in Thread order. Positions preserve the hidden-gap counts without
+ * loading the omitted Posts or their related metadata.
+ */
+export interface FeaturedThreadTimelineData {
+  posts: FeaturedThreadTimelinePost[];
+  featuredPostIds: string[];
+}
+
 export interface PostBodyContent {
   id: string;
   type: "post";
@@ -223,7 +313,7 @@ export interface PostService {
   count(filters?: PostFilters): Promise<number>;
   /** Count posts matching filters up to a fixed limit (ignores cursor, offset, limit) */
   countUpTo(filters: PostFilters | undefined, limit: number): Promise<number>;
-  /** Count posts grouped by published year-month (YYYY-MM) */
+  /** Count posts grouped by year-month (YYYY-MM) on the `sortBy` time axis */
   countByYearMonth(
     filters?: PostFilters,
   ): Promise<{ yearMonth: string; count: number }[]>;
@@ -237,6 +327,8 @@ export interface PostService {
   /**
    * Atomically create a thread of posts. The first item is the root; each
    * subsequent item is automatically chained as a reply to the previous one.
+   * When the first item quietly extends an existing thread, the quiet behavior
+   * applies to every new reply in the batch.
    * On failure, all already-created posts are rolled back.
    *
    * @param items - Ordered list of (data, attachments) pairs; at least 2 required
@@ -278,6 +370,21 @@ export interface PostService {
    */
   deleteThreadDraft(id: string, deps?: PostDeleteDeps): Promise<boolean>;
   getThread(rootId: string): Promise<Post[]>;
+  /**
+   * 1-based position of a Post in the reply chain running from its Thread root
+   * down to it: a root is 1, a reply to it is 2, a reply to that is 3.
+   *
+   * Threads are stored as a tree (`replyToId`) flattened under one `threadId`,
+   * so this is the Post's depth, not how many Posts the Thread holds — two
+   * replies to the same parent are both at the same position.
+   *
+   * @param postId - TypeID of the Post to locate
+   * @returns The 1-based position, or 0 when no such Post exists
+   * @example
+   * // Root -> reply -> reply, asked about the last one
+   * await posts.getThreadPosition(lastId); // => 3
+   */
+  getThreadPosition(postId: string): Promise<number>;
   updateThreadStatusAndVisibility(
     rootId: string,
     status: Status,
@@ -296,8 +403,12 @@ export interface PostService {
   ): Promise<Map<string, ThreadTimelineContext>>;
   /** Count distinct thread roots that contain featured published posts */
   countFeaturedThreadRoots(options?: ThreadRootPageOptions): Promise<number>;
-  /** List featured thread root IDs ordered by the latest featured post in each thread */
+  /** List Featured Thread roots by the latest selected Post publication time. */
   listFeaturedThreadRootIds(options?: ThreadRootPageOptions): Promise<string[]>;
+  /** Load only the Posts rendered by the curated Featured Thread timeline. */
+  getFeaturedThreadTimelineData(
+    rootIds: string[],
+  ): Promise<Map<string, FeaturedThreadTimelineData>>;
   /** Count distinct thread roots that contain published posts in the given collection */
   countCollectionThreadRoots(
     collectionId: string,
@@ -308,6 +419,12 @@ export interface PostService {
     collectionIds: string[],
     options?: ThreadRootPageOptions,
   ): Promise<number>;
+  /** Count distinct matching collection Threads up to a fixed limit. */
+  countCollectionThreadRootsUpToForCollections(
+    collectionIds: string[],
+    options: ThreadRootPageOptions | undefined,
+    limit: number,
+  ): Promise<number>;
   /** List collection thread root IDs ordered by collected-at or rating semantics */
   listCollectionThreadRootIds(
     collectionId: string,
@@ -318,6 +435,11 @@ export interface PostService {
     collectionIds: string[],
     options?: CollectionThreadRootPageOptions,
   ): Promise<string[]>;
+  /** List and hydrate collection Thread roots using Thread-level ordering. */
+  listCollectionThreadRootsForCollections(
+    collectionIds: string[],
+    options?: CollectionThreadRootPageOptions,
+  ): Promise<Post[]>;
   /** List collection feed entries ordered by latest added-at timestamp */
   listCollectionFeedEntries(
     collectionId: string,
@@ -328,22 +450,36 @@ export interface PostService {
     collectionIds: string[],
     options?: CollectionFeedEntryOptions,
   ): Promise<CollectionFeedEntry[]>;
-  /** Fetch all published, non-deleted posts for each requested thread root */
-  getPublishedThreads(rootIds: string[]): Promise<Map<string, Post[]>>;
-  /** For each thread, return post IDs that belong to the given collection */
-  getCollectionPostIdsByThread(
-    collectionId: string,
-    threadIds: string[],
-  ): Promise<Map<string, string[]>>;
-  /** For each thread, return post IDs that belong to any of the given collections */
-  getCollectionPostIdsByThreadForCollections(
-    collectionIds: string[],
-    threadIds: string[],
-  ): Promise<Map<string, string[]>>;
-  /** Get distinct years that have published posts */
+  /** Fetch published Posts for each requested Thread root. */
+  getPublishedThreads(
+    rootIds: string[],
+    options?: Pick<PostFilters, "publishedBefore">,
+  ): Promise<Map<string, Post[]>>;
+  /** Get distinct years with posts, bucketed on the `sortBy` time axis */
   getDistinctYears(filters?: PostFilters): Promise<number[]>;
-  /** For each thread ID, return the ID of the last published, non-deleted post */
-  getLastPostIdsByThread(threadIds: string[]): Promise<Map<string, string>>;
+  /**
+   * For each Thread ID, resolve the Post that currently ends the chain.
+   *
+   * Two callers need two different answers. Readers ask what the audience can
+   * see, so drafts must not count — the Reply affordance belongs on the last
+   * published Post. The reply guard asks what the chain physically ends with,
+   * and there an unpublished draft still owns the slot: attaching a second
+   * reply to the same parent would fork a structure that is meant to be linear.
+   *
+   * @param threadIds - Thread root IDs to resolve (duplicates are fine)
+   * @param options - `includeDrafts` counts unpublished members as the tail
+   * @returns Map of Thread root ID to its tail Post ID; threads with no
+   *   matching member are absent from the map
+   * @example
+   * ```ts
+   * const tails = await posts.getThreadTailIds([root.id], { includeDrafts: true });
+   * const tailId = tails.get(root.id);
+   * ```
+   */
+  getThreadTailIds(
+    threadIds: string[],
+    options?: { includeDrafts?: boolean },
+  ): Promise<Map<string, string>>;
   /**
    * Rebuild `post.body_text` for a batch of non-deleted posts, cursor-paginated
    * by post id. For each row, recomputes the plain-text extraction via
@@ -366,6 +502,44 @@ export interface PostService {
     nextCursor: string | null;
     done: boolean;
   }>;
+  /**
+   * Upgrade recognized legacy footnotes and rebuild stored post body HTML for
+   * this site.
+   *
+   * Updates use compare-and-swap guards so concurrent edits win. Editorial
+   * timestamps are never touched. The operation is cursor-paginated,
+   * idempotent, and supports a read-only dry run.
+   */
+  rebuildBodyHtml(
+    options?: RebuildBodyHtmlOptions,
+  ): Promise<RebuildBodyHtmlResult>;
+}
+
+/**
+ * Rebuild body HTML using the site's current runtime summary settings.
+ *
+ * Internal maintenance routes do not run behind the normal app-config
+ * middleware, so this service-level orchestration preserves the same
+ * DB → environment → built-in resolution used by regular requests.
+ *
+ * @param services - Site-scoped post and settings services.
+ * @param env - Runtime environment bindings.
+ * @param options - Rebuild options supplied by the maintenance caller.
+ * @returns Rebuild progress and outcome counts.
+ */
+export async function rebuildPostBodyHtmlWithRuntimeSettings(
+  services: Pick<
+    { posts: PostService; settings: SettingsService },
+    "posts" | "settings"
+  >,
+  env: Bindings,
+  options: Omit<RebuildBodyHtmlOptions, "summaryConfig"> = {},
+): Promise<RebuildBodyHtmlResult> {
+  const allSettings = await services.settings.getAll();
+  return services.posts.rebuildBodyHtml({
+    ...options,
+    summaryConfig: resolveSummaryConfig(env, allSettings),
+  });
 }
 
 const SLUG_RE = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
@@ -521,20 +695,32 @@ export function createPostService(
   databaseSchema: DatabaseSchema = sqliteSchemaBundle,
 ): PostService {
   const resolvedPaths = paths ?? createPathService(db, siteId, databaseSchema);
-  const { pathRegistry, posts, postCollections } = databaseSchema;
+  const { navItems, pathRegistry, posts, sites, threadCollections } =
+    databaseSchema;
   const databaseDialect = config.databaseDialect ?? "sqlite";
   const usesBatchWrites = !supportsDrizzleTransaction(db, databaseDialect);
 
-  function buildPublishedYearMonthExpr(): SQL<string> {
+  /**
+   * Column that carries the time axis selected by `PostFilters.sortBy`.
+   * Sorting, year/month bucketing, and date-range filters all read it through
+   * here so they can never drift onto different columns.
+   */
+  function timeAxisColumn(filters: Pick<PostFilters, "sortBy">) {
+    if (filters.sortBy === "activity") return posts.lastActivityAt;
+    if (filters.sortBy === "thread_updated") return posts.threadUpdatedAt;
+    return posts.publishedAt;
+  }
+
+  function buildYearMonthExpr(column: SQLWrapper): SQL<string> {
     return databaseDialect === "pg"
-      ? sql<string>`to_char(timezone('UTC', to_timestamp(${posts.publishedAt})), 'YYYY-MM')`
-      : sql<string>`strftime('%Y-%m', ${posts.publishedAt}, 'unixepoch')`;
+      ? sql<string>`to_char(timezone('UTC', to_timestamp(${column})), 'YYYY-MM')`
+      : sql<string>`strftime('%Y-%m', ${column}, 'unixepoch')`;
   }
 
-  function buildPublishedYearExpr(): SQL<string> {
+  function buildYearExpr(column: SQLWrapper): SQL<string> {
     return databaseDialect === "pg"
-      ? sql<string>`to_char(timezone('UTC', to_timestamp(${posts.publishedAt})), 'YYYY')`
-      : sql<string>`strftime('%Y', ${posts.publishedAt}, 'unixepoch')`;
+      ? sql<string>`to_char(timezone('UTC', to_timestamp(${column})), 'YYYY')`
+      : sql<string>`strftime('%Y', ${column}, 'unixepoch')`;
   }
 
   const effectiveVisibilityExpr = sql<string>`coalesce(
@@ -575,28 +761,58 @@ export function createPostService(
     return rows.length > 0;
   }
 
-  async function recalculateThreadLastActivity(rootId: string): Promise<void> {
+  /**
+   * Recompute both Thread activity timestamps on the root from the Thread's
+   * rows.
+   *
+   * - `lastActivityAt` — newest published post excluding quiet replies. This
+   *   is "last announced" and drives Latest and the feeds.
+   * - `threadUpdatedAt` — newest published post including quiet replies. This
+   *   is "last changed" and drives the archive's updated sort.
+   *
+   * Both are derived, never accumulated, so a quiet reply stays quiet no
+   * matter what later edits or deletions trigger a recalculation.
+   *
+   * @param rootId - Thread root post ID
+   */
+  async function recalculateThreadActivity(rootId: string): Promise<void> {
     const rootRows = await db
       .select({
-        latestPublishedAt: sql<number | null>`MAX(${posts.publishedAt})`.as(
-          "latest_published_at",
+        announcedAt: sql<number | null>`MAX(
+          CASE
+            WHEN ${posts.quietReply} THEN NULL
+            ELSE ${posts.publishedAt}
+          END
+        )`.as("announced_at"),
+        updatedAt: sql<number | null>`MAX(${posts.publishedAt})`.as(
+          "thread_updated_at",
         ),
       })
       .from(posts)
-      .where(and(eq(posts.siteId, siteId), eq(posts.threadId, rootId)));
+      .where(
+        and(
+          eq(posts.siteId, siteId),
+          eq(posts.threadId, rootId),
+          eq(posts.status, "published"),
+        ),
+      );
 
-    const latestPublishedAt = rootRows[0]?.latestPublishedAt ?? null;
+    const announcedAt = rootRows[0]?.announcedAt ?? null;
+    const threadUpdatedAt = rootRows[0]?.updatedAt ?? null;
     const root = await db
       .select({ updatedAt: posts.updatedAt })
       .from(posts)
       .where(and(eq(posts.siteId, siteId), eq(posts.id, rootId)))
       .limit(1);
 
-    const lastActivityAt = latestPublishedAt ?? root[0]?.updatedAt ?? now();
+    const fallback = root[0]?.updatedAt ?? now();
 
     await db
       .update(posts)
-      .set({ lastActivityAt })
+      .set({
+        lastActivityAt: announcedAt ?? fallback,
+        threadUpdatedAt: threadUpdatedAt ?? fallback,
+      })
       .where(and(eq(posts.siteId, siteId), eq(posts.id, rootId)));
   }
 
@@ -695,11 +911,11 @@ export function createPostService(
     }
 
     return uniqueCollectionIds.length === 1
-      ? eq(postCollections.collectionId, firstCollectionId)
-      : inArray(postCollections.collectionId, uniqueCollectionIds);
+      ? eq(threadCollections.collectionId, firstCollectionId)
+      : inArray(threadCollections.collectionId, uniqueCollectionIds);
   }
 
-  function buildPostCollectionSubqueryCondition(
+  function buildThreadCollectionSubqueryCondition(
     collectionIds: readonly string[],
   ): SQL<unknown> {
     const uniqueCollectionIds = normalizeCollectionIds(collectionIds);
@@ -710,9 +926,9 @@ export function createPostService(
     const placeholders = uniqueCollectionIds.map(
       (collectionId) => sql`${collectionId}`,
     );
-    return sql`${posts.id} IN (
-      SELECT post_id
-      FROM post_collection
+    return sql`${posts.threadId} IN (
+      SELECT thread_id
+      FROM thread_collection
       WHERE site_id = ${siteId}
         AND collection_id IN (${sql.join(placeholders, sql`, `)})
     )`;
@@ -753,11 +969,11 @@ export function createPostService(
     }
     if (filters.collectionIds !== undefined) {
       conditions.push(
-        buildPostCollectionSubqueryCondition(filters.collectionIds),
+        buildThreadCollectionSubqueryCondition(filters.collectionIds),
       );
     } else if (filters.collectionId !== undefined) {
       conditions.push(
-        buildPostCollectionSubqueryCondition([filters.collectionId]),
+        buildThreadCollectionSubqueryCondition([filters.collectionId]),
       );
     }
     if (filters.threadId) {
@@ -772,6 +988,15 @@ export function createPostService(
     if (filters.publishedBefore !== undefined) {
       conditions.push(sql`${posts.publishedAt} < ${filters.publishedBefore}`);
     }
+    if (filters.axisAfter !== undefined || filters.axisBefore !== undefined) {
+      const axis = timeAxisColumn(filters);
+      if (filters.axisAfter !== undefined) {
+        conditions.push(sql`${axis} >= ${filters.axisAfter}`);
+      }
+      if (filters.axisBefore !== undefined) {
+        conditions.push(sql`${axis} < ${filters.axisBefore}`);
+      }
+    }
     if (filters.mediaKinds && filters.mediaKinds.length > 0) {
       const placeholders = filters.mediaKinds.map((k) => sql`${k}`);
       conditions.push(
@@ -784,19 +1009,13 @@ export function createPostService(
       );
     }
     if (filters.hasMedia !== undefined) {
-      if (filters.hasMedia) {
-        conditions.push(
-          sql`${posts.id} IN (
-            SELECT post_id FROM media WHERE site_id = ${siteId}
-          )`,
-        );
-      } else {
-        conditions.push(
-          sql`${posts.id} NOT IN (
-            SELECT post_id FROM media WHERE site_id = ${siteId}
-          )`,
-        );
-      }
+      const mediaExists = sql`EXISTS (
+        SELECT 1
+        FROM media
+        WHERE site_id = ${siteId}
+          AND post_id = ${posts.id}
+      )`;
+      conditions.push(filters.hasMedia ? mediaExists : sql`NOT ${mediaExists}`);
     }
     if (filters.hasTitle !== undefined) {
       if (filters.hasTitle) {
@@ -831,21 +1050,38 @@ export function createPostService(
     return conditions;
   }
 
-  async function getLastLivePostIdInThread(
-    threadId: string,
-  ): Promise<string | null> {
-    const rows = await db
-      .select({ id: posts.id })
-      .from(posts)
-      .where(and(eq(posts.siteId, siteId), eq(posts.threadId, threadId)))
-      .orderBy(desc(posts.createdAt), desc(posts.id))
-      .limit(1);
-
-    return rows[0]?.id ?? null;
+  function getCursorSortTimestamp(
+    row: typeof posts.$inferSelect,
+    filters: PostFilters,
+  ): number {
+    if (filters.sortBy === "published") {
+      return row.publishedAt ?? row.createdAt;
+    }
+    if (filters.sortBy === "thread_updated") {
+      return row.threadUpdatedAt ?? -1;
+    }
+    return row.status === "draft" ? row.updatedAt : (row.lastActivityAt ?? -1);
   }
 
-  function getCursorSortTimestamp(row: typeof posts.$inferSelect): number {
-    return row.status === "draft" ? row.updatedAt : (row.lastActivityAt ?? -1);
+  /**
+   * Chronological sort key for `list()`.
+   *
+   * Shared by the ORDER BY and the keyset cursor comparison — they must read
+   * the same expression or pagination silently skips or repeats rows.
+   */
+  function buildSortTimestampExpr(filters: PostFilters): SQLWrapper {
+    if (filters.sortBy === "published") {
+      return sql<number>`coalesce(${posts.publishedAt}, ${posts.createdAt})`;
+    }
+    if (filters.sortBy === "thread_updated") {
+      return posts.threadUpdatedAt;
+    }
+    if (filters.status === "draft") return posts.updatedAt;
+    if (filters.status === "published") return posts.lastActivityAt;
+    return sql<number>`CASE
+      WHEN ${posts.status} = 'draft' THEN ${posts.updatedAt}
+      ELSE ${posts.lastActivityAt}
+    END`;
   }
 
   function buildLexicographicCursorCondition(
@@ -887,17 +1123,11 @@ export function createPostService(
       return null;
     }
 
-    const sortTimestampExpr =
-      filters.status === "draft"
-        ? posts.updatedAt
-        : filters.status === "published"
-          ? posts.lastActivityAt
-          : sql<number>`CASE
-              WHEN ${posts.status} = 'draft' THEN ${posts.updatedAt}
-              ELSE ${posts.lastActivityAt}
-            END`;
+    const sortTimestampExpr = buildSortTimestampExpr(filters);
     const pinnedSortExpr = sql<number>`coalesce(${posts.pinnedAt}, -1)`;
-    const featuredSortExpr = sql<number>`coalesce(${posts.featuredAt}, -1)`;
+    const featuredPublishedSortExpr = sql<number>`coalesce(
+      ${posts.publishedAt}, ${posts.createdAt}, -1
+    )`;
     const sortTimestampSortExpr = sql<number>`coalesce(${sortTimestampExpr}, -1)`;
     const ratingPresenceExpr = sql<number>`CASE
       WHEN ${posts.rating} IS NULL THEN 0
@@ -905,8 +1135,9 @@ export function createPostService(
     END`;
     const ratingSortExpr = sql<number>`coalesce(${posts.rating}, -1)`;
     const cursorPinnedAt = cursorPost.pinnedAt ?? -1;
-    const cursorFeaturedAt = cursorPost.featuredAt ?? -1;
-    const cursorSortTimestamp = getCursorSortTimestamp(cursorPost);
+    const cursorFeaturedPublishedAt =
+      cursorPost.publishedAt ?? cursorPost.createdAt;
+    const cursorSortTimestamp = getCursorSortTimestamp(cursorPost, filters);
     const cursorRatingPresence = cursorPost.rating === null ? 0 : 1;
     const cursorRating = cursorPost.rating ?? -1;
     const withPinnedSortKey = (
@@ -925,8 +1156,8 @@ export function createPostService(
           withPinnedSortKey([
             {
               direction: "desc",
-              expr: featuredSortExpr,
-              value: cursorFeaturedAt,
+              expr: featuredPublishedSortExpr,
+              value: cursorFeaturedPublishedAt,
             },
             { direction: "desc", expr: posts.id, value: cursorPost.id },
           ]),
@@ -1012,7 +1243,12 @@ export function createPostService(
       title: row.title,
       url: row.url,
       body: row.body,
-      bodyHtml: row.bodyHtml,
+      bodyHtml: resolvePostBodyHtml({
+        id: row.id,
+        body: row.body,
+        bodyHtml: row.bodyHtml,
+        bodyHtmlVersion: row.bodyHtmlVersion,
+      }),
       bodyText: row.bodyText,
       quoteText: row.quoteText,
       summary: row.summary,
@@ -1022,8 +1258,14 @@ export function createPostService(
       previewProvider: row.previewProvider,
       replyToId: row.replyToId,
       threadId: row.threadId,
+      quietReply: row.quietReply,
       publishedAt: row.publishedAt,
       lastActivityAt: row.lastActivityAt ?? row.publishedAt ?? row.updatedAt,
+      threadUpdatedAt:
+        row.threadUpdatedAt ??
+        row.lastActivityAt ??
+        row.publishedAt ??
+        row.updatedAt,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
     };
@@ -1122,15 +1364,50 @@ export function createPostService(
     if (options?.excludePrivate) {
       conditions.push(sql`${effectiveVisibilityExpr} != 'private'`);
     }
+    if (options?.excludeLatestHidden) {
+      conditions.push(sql`${effectiveVisibilityExpr} != 'latest_hidden'`);
+    }
+    if (options?.publishedBefore !== undefined) {
+      conditions.push(
+        sql`${posts.publishedAt} < ${options.publishedBefore}`,
+        sql`EXISTS (
+          SELECT 1
+          FROM post AS publication_root
+          WHERE publication_root.site_id = ${siteId}
+            AND publication_root.id = ${posts.threadId}
+            AND publication_root.published_at < ${options.publishedBefore}
+        )`,
+      );
+    }
+    if (options?.rootFormat) {
+      conditions.push(sql`EXISTS (
+        SELECT 1
+        FROM post AS collection_root
+        WHERE collection_root.site_id = ${siteId}
+          AND collection_root.id = ${posts.threadId}
+          AND collection_root.format = ${options.rootFormat}
+      )`);
+    }
+    if (options?.hasRating) {
+      conditions.push(isNotNull(posts.rating));
+    }
 
     return conditions;
   }
 
+  /**
+   * Thread activity timestamp used to order collection threads.
+   *
+   * Rows here are Thread *members* grouped by thread_id, so the definition is
+   * reached through a subquery to the root. The outer MAX only collapses the
+   * group — the subquery returns one value per thread. The outer COALESCE
+   * covers a member whose root row is missing.
+   */
   function buildCollectionThreadActivityExpr(alias: string) {
     return sql<number>`MAX(
       COALESCE(
         (
-          SELECT root.last_activity_at
+          SELECT ${buildRootActivityExpr(rootActivityColumns("root"))}
           FROM post AS root
           WHERE root.site_id = ${siteId}
             AND root.id = ${posts.threadId}
@@ -1141,6 +1418,59 @@ export function createPostService(
     )`.as(alias);
   }
 
+  function buildCollectionThreadSortQuery(
+    collectionIds: string[],
+    options: CollectionThreadRootPageOptions,
+  ) {
+    const conditions = [
+      ...buildThreadRootPageConditions(options),
+      buildCollectionMembershipCondition(collectionIds),
+    ];
+    const sortOrder = options.sortOrder ?? "newest";
+    const publishedAt =
+      sortOrder === "oldest"
+        ? sql<number>`MIN(${posts.publishedAt})`.as("published_at")
+        : sql<number>`MAX(${posts.publishedAt})`.as("published_at");
+    const threadActivityAt =
+      buildCollectionThreadActivityExpr("thread_activity_at");
+    const ratingPresence = sql<number>`MAX(
+      CASE
+        WHEN ${posts.rating} IS NULL THEN 0
+        ELSE 1
+      END
+    )`.as("rating_presence");
+    const ratingValue = sql<number>`MAX(coalesce(${posts.rating}, -1))`.as(
+      "rating_value",
+    );
+    const collectionPinnedAt =
+      sql<number>`MAX(coalesce(${threadCollections.pinnedAt}, -1))`.as(
+        "collection_pinned_at",
+      );
+
+    const sortedThreads = db
+      .select({
+        threadId: posts.threadId,
+        publishedAt,
+        threadActivityAt,
+        collectionPinnedAt,
+        ratingPresence,
+        ratingValue,
+      })
+      .from(posts)
+      .innerJoin(
+        threadCollections,
+        and(
+          eq(threadCollections.siteId, posts.siteId),
+          eq(threadCollections.threadId, posts.threadId),
+        ),
+      )
+      .where(and(...conditions))
+      .groupBy(posts.threadId)
+      .as("collection_thread_sort");
+
+    return { sortOrder, sortedThreads };
+  }
+
   function isMediaAttachmentInput(
     attachment: PostAttachmentInput,
   ): attachment is Extract<PostAttachmentInput, { type: "media" }> {
@@ -1210,36 +1540,50 @@ export function createPostService(
     await deps.media.deleteByIds(mediaIds, deps.storage).catch(() => undefined);
   }
 
-  async function getCollectionIdsForPost(postId: string): Promise<string[]> {
+  async function getCollectionIdsForThread(
+    threadId: string,
+  ): Promise<string[]> {
     const rows = await db
-      .select({ collectionId: postCollections.collectionId })
-      .from(postCollections)
+      .select({ collectionId: threadCollections.collectionId })
+      .from(threadCollections)
       .where(
         and(
-          eq(postCollections.siteId, siteId),
-          eq(postCollections.postId, postId),
+          eq(threadCollections.siteId, siteId),
+          eq(threadCollections.threadId, threadId),
         ),
       );
 
     return rows.map((row) => row.collectionId);
   }
 
-  async function getPostCollectionTimestamps(
-    postId: string,
-  ): Promise<Map<string, number>> {
+  async function getThreadCollectionEntries(threadId: string): Promise<
+    Map<
+      string,
+      {
+        createdAt: number;
+        pinnedAt: number | null;
+      }
+    >
+  > {
     const rows = await db
       .select({
-        collectionId: postCollections.collectionId,
-        createdAt: postCollections.createdAt,
+        collectionId: threadCollections.collectionId,
+        createdAt: threadCollections.createdAt,
+        pinnedAt: threadCollections.pinnedAt,
       })
-      .from(postCollections)
+      .from(threadCollections)
       .where(
         and(
-          eq(postCollections.siteId, siteId),
-          eq(postCollections.postId, postId),
+          eq(threadCollections.siteId, siteId),
+          eq(threadCollections.threadId, threadId),
         ),
       );
-    return new Map(rows.map((r) => [r.collectionId, r.createdAt]));
+    return new Map(
+      rows.map((row) => [
+        row.collectionId,
+        { createdAt: row.createdAt, pinnedAt: row.pinnedAt },
+      ]),
+    );
   }
 
   function buildRollbackUpdate(
@@ -1323,15 +1667,7 @@ export function createPostService(
       if (filters.cursor && !cursorCondition) {
         return [];
       }
-      const sortTimestamp =
-        filters.status === "draft"
-          ? posts.updatedAt
-          : filters.status === "published"
-            ? posts.lastActivityAt
-            : sql<number>`CASE
-                WHEN ${posts.status} = 'draft' THEN ${posts.updatedAt}
-                ELSE ${posts.lastActivityAt}
-              END`;
+      const sortTimestamp = buildSortTimestampExpr(filters);
 
       if (cursorCondition) {
         conditions.push(cursorCondition);
@@ -1344,10 +1680,13 @@ export function createPostService(
 
       // NULL-sort order differs between dialects: SQLite puts NULLs last for
       // DESC, Postgres puts them first. Wrap nullable sort keys in COALESCE
-      // so pinned/featured posts land on top under both engines. Mirrors the
+      // so pinned and nullable timeline values sort identically under both
+      // engines. Mirrors the
       // expressions used by `buildListCursorCondition` above.
       const pinnedSortExpr = sql<number>`coalesce(${posts.pinnedAt}, -1)`;
-      const featuredSortExpr = sql<number>`coalesce(${posts.featuredAt}, -1)`;
+      const featuredPublishedSortExpr = sql<number>`coalesce(
+        ${posts.publishedAt}, ${posts.createdAt}, -1
+      )`;
       const sortTimestampSortExpr = sql<number>`coalesce(${sortTimestamp}, -1)`;
       const pinnedOrder = filters.ignorePinnedSort
         ? []
@@ -1364,7 +1703,7 @@ export function createPostService(
           ? baseQuery.orderBy(
               ...pinnedOrder,
               filters.featured
-                ? desc(featuredSortExpr)
+                ? desc(featuredPublishedSortExpr)
                 : desc(sortTimestampSortExpr),
               desc(posts.id),
             )
@@ -1410,10 +1749,30 @@ export function createPostService(
         conditions.push(sql`${posts.id} > ${afterId}`);
       }
 
+      // `lastmod` describes the page, and a Thread root's page renders its
+      // replies too — so an added or edited reply changes it even though the
+      // root row is untouched. Unlike ordering, edits do count here: the page
+      // really did change. Mirrors `articleModifiedTime` in lib/post-display.
+      //
+      // The outer columns are written out rather than interpolated: Drizzle
+      // only qualifies projection columns when the query has a join, so
+      // `${posts.id}` would render as a bare "id" here and bind to the
+      // subquery's own alias instead of correlating to the outer row.
+      const threadModifiedAt = sql<number>`COALESCE(
+        (
+          SELECT MAX(member.updated_at)
+          FROM post AS member
+          WHERE member.site_id = ${siteId}
+            AND member.thread_id = "post"."id"
+            AND member.status = 'published'
+        ),
+        "post"."updated_at"
+      )`;
+
       const rows = await db
         .select({
           id: posts.id,
-          updatedAt: posts.updatedAt,
+          updatedAt: threadModifiedAt,
           featuredAt: posts.featuredAt,
         })
         .from(posts)
@@ -1503,11 +1862,9 @@ export function createPostService(
     },
 
     async countByYearMonth(filters = {}) {
-      const conditions = [
-        ...buildFilterConditions(filters),
-        isNotNull(posts.publishedAt),
-      ];
-      const publishedYearMonthExpr = buildPublishedYearMonthExpr();
+      const axis = timeAxisColumn(filters);
+      const conditions = [...buildFilterConditions(filters), isNotNull(axis)];
+      const publishedYearMonthExpr = buildYearMonthExpr(axis);
 
       return db
         .select({
@@ -1531,11 +1888,17 @@ export function createPostService(
           ? ensurePostVisibility(data.visibility)
           : undefined;
       const rating = ensurePostRating(data.rating);
+      // Only replies can be quiet — a root has nothing to stay quiet about.
+      const isQuietReply = Boolean(data.replyToId) && data.quietReply === true;
 
       const rawBody = data.bodyMarkdown
         ? markdownToTiptapJson(data.bodyMarkdown)
         : (data.body ?? null);
-      const body = rawBody ? trimTiptapBody(rawBody) : null;
+      const trimmedBody = rawBody ? trimTiptapBody(rawBody) : null;
+      const preparedBody = trimmedBody
+        ? tryPreparePostBodyHtml(id, trimmedBody)
+        : null;
+      const body = preparedBody?.ok ? preparedBody.body : trimmedBody;
       const title = data.title?.trim() || null;
       const quoteText = data.quoteText?.trim() || null;
       const url = data.url?.trim() || null;
@@ -1551,7 +1914,11 @@ export function createPostService(
           : undefined,
       });
 
-      const bodyHtml = body ? renderTiptapJson(body) : null;
+      const bodyHtml = preparedBody?.ok
+        ? preparedBody.html
+        : body
+          ? renderPostBodyHtml(id, body)
+          : null;
       const bodyText = body
         ? extractBodyText(body, { includeLinkHrefs: true })
         : null;
@@ -1603,10 +1970,19 @@ export function createPostService(
           );
         }
 
-        const lastLivePostId = await getLastLivePostIdInThread(parent.threadId);
-        if (lastLivePostId && lastLivePostId !== parent.id) {
+        // Drafts count here: an unpublished reply already owns the tail slot,
+        // and a sibling attached to the same parent would fork the chain.
+        const tailId = (
+          await this.getThreadTailIds([parent.threadId], {
+            includeDrafts: true,
+          })
+        ).get(parent.threadId);
+        if (tailId && tailId !== parent.id) {
+          const tail = await this.getById(tailId);
           throw new ConflictError(
-            "This post is no longer the end of the thread. Reply to the latest post instead.",
+            tail?.status === "draft"
+              ? "This thread ends with an unpublished draft. Finish that draft or discard it, then reply."
+              : "This post is no longer the end of the thread. Reply to the latest post instead.",
           );
         }
 
@@ -1617,12 +1993,29 @@ export function createPostService(
           parent.threadId === parent.id
             ? parent
             : await this.getById(parent.threadId);
-        if (root) {
-          if (data.status !== "draft") {
-            status = root.status;
-          }
+        // A reply takes the root's status. A draft earlier in the chain does
+        // not hold it back: readers never saw that post, so publishing past it
+        // reads as continuous, and the draft stays parked until it is dealt
+        // with on its own.
+        if (root && data.status !== "draft") {
+          status = root.status;
         }
         visibility = null;
+
+        if (
+          (data.collectionIds?.length ?? 0) > 0 ||
+          (data.collectionEntries?.length ?? 0) > 0
+        ) {
+          throw new ConflictError(
+            "Cannot set Collections while creating a Thread reply. Set them on the Thread root instead.",
+          );
+        }
+      }
+
+      // Featured surfaces only list published posts, so featuring a draft
+      // writes a flag that does nothing and shows nowhere. Say so instead.
+      if (status === "draft" && resolvedFeaturedAt !== null) {
+        throw new ConflictError("Publish this post before featuring it.");
       }
 
       assertDraftPublishedAt(status, data.publishedAt);
@@ -1643,6 +2036,11 @@ export function createPostService(
 
       if (data.path) {
         const normalized = normalizePath(data.path);
+        if (isReservedPath(normalized)) {
+          throw new ValidationError(
+            `Path "${normalized}" is reserved and cannot be used`,
+          );
+        }
         if (isValidSlug(normalized)) {
           // Path is a valid slug — use it directly
           slug = await generatePostSlug({
@@ -1674,7 +2072,8 @@ export function createPostService(
         });
       }
 
-      // When structured `collectionEntries` are provided (Hugo import path),
+      // Thread collection membership is stored against the root ID. When
+      // structured `collectionEntries` are provided (Hugo import path),
       // they win over the bare `collectionIds` slug list and carry
       // `createdAt` / `position` / `pinnedAt` per row. Otherwise fall back to
       // the simple list and derive those fields from sensible defaults.
@@ -1683,7 +2082,7 @@ export function createPostService(
         data.collectionEntries.length > 0;
       const collectionInsertRows: {
         siteId: string;
-        postId: string;
+        threadId: string;
         collectionId: string;
         createdAt: number;
         position: number;
@@ -1693,7 +2092,7 @@ export function createPostService(
             const seen = new Set<string>();
             const rows: {
               siteId: string;
-              postId: string;
+              threadId: string;
               collectionId: string;
               createdAt: number;
               position: number;
@@ -1705,7 +2104,7 @@ export function createPostService(
               seen.add(entry.collectionId);
               rows.push({
                 siteId,
-                postId: id,
+                threadId,
                 collectionId: entry.collectionId,
                 createdAt: entry.createdAt ?? timestamp,
                 position: entry.position ?? fallbackPosition,
@@ -1717,7 +2116,7 @@ export function createPostService(
           })()
         : [...new Set(data.collectionIds ?? [])].map((collectionId, index) => ({
             siteId,
-            postId: id,
+            threadId,
             collectionId,
             createdAt: timestamp,
             position: index,
@@ -1741,14 +2140,17 @@ export function createPostService(
               url,
               body,
               bodyHtml,
+              bodyHtmlVersion: POST_BODY_HTML_VERSION,
               bodyText,
               quoteText,
               summary,
               rating,
               replyToId: data.replyToId ?? null,
               threadId,
+              quietReply: isQuietReply,
               publishedAt,
               lastActivityAt: publishedAt ?? timestamp,
+              threadUpdatedAt: publishedAt ?? timestamp,
               createdAt: timestamp,
               updatedAt: timestamp,
             }),
@@ -1788,7 +2190,12 @@ export function createPostService(
 
           if (collectionInsertRows.length > 0) {
             writeQueries.push(
-              db.insert(postCollections).values(collectionInsertRows),
+              data.replyToId
+                ? db
+                    .insert(threadCollections)
+                    .values(collectionInsertRows)
+                    .onConflictDoNothing()
+                : db.insert(threadCollections).values(collectionInsertRows),
             );
           }
 
@@ -1812,14 +2219,17 @@ export function createPostService(
               url,
               body,
               bodyHtml,
+              bodyHtmlVersion: POST_BODY_HTML_VERSION,
               bodyText,
               quoteText,
               summary,
               rating,
               replyToId: data.replyToId ?? null,
               threadId,
+              quietReply: isQuietReply,
               publishedAt,
               lastActivityAt: publishedAt ?? timestamp,
+              threadUpdatedAt: publishedAt ?? timestamp,
               createdAt: timestamp,
               updatedAt: timestamp,
             });
@@ -1853,7 +2263,14 @@ export function createPostService(
             }
 
             if (collectionInsertRows.length > 0) {
-              await tx.insert(postCollections).values(collectionInsertRows);
+              const insertQuery = tx
+                .insert(threadCollections)
+                .values(collectionInsertRows);
+              if (data.replyToId) {
+                await insertQuery.onConflictDoNothing();
+              } else {
+                await insertQuery;
+              }
             }
           });
         }
@@ -1872,9 +2289,11 @@ export function createPostService(
         throw new ConflictError(`Slug "${slug}" could not be resolved`);
       }
 
-      // Bump thread root's lastActivityAt when creating a published reply
-      if (data.replyToId && status === "published" && !data.quietReply) {
-        await recalculateThreadLastActivity(threadId);
+      // A quiet reply still changes the Thread, it just isn't announced —
+      // the recalculation reads the persisted quiet_reply flag and keeps
+      // lastActivityAt where it was while moving threadUpdatedAt forward.
+      if (data.replyToId && status === "published") {
+        await recalculateThreadActivity(threadId);
       }
 
       return post;
@@ -1926,6 +2345,9 @@ export function createPostService(
         throw new ValidationError("A thread requires at least 2 posts.");
       }
 
+      const extendsExistingThreadQuietly =
+        items[0]?.data.replyToId !== undefined &&
+        items[0].data.quietReply === true;
       const created: Post[] = [];
 
       for (let i = 0; i < items.length; i++) {
@@ -1933,10 +2355,19 @@ export function createPostService(
         if (!item) continue;
         const { data, attachments } = item;
         const prevPost = created[i - 1];
+        // A reply with no date of its own belongs to the root's moment, not to
+        // whenever the request happened to run. Without this, backdating the
+        // root leaves its replies stamped today and the thread reads as if it
+        // spanned years. Thread order is by `createdAt`/`id` (see the thread
+        // queries), so sharing one `publishedAt` cannot reorder anything.
+        const rootPublishedAt = created[0]?.publishedAt ?? undefined;
         const postData: CreatePost = {
           ...data,
           // Chain each post as a reply to the previous one (server-side chaining)
           replyToId: i === 0 ? data.replyToId : prevPost?.id,
+          quietReply: extendsExistingThreadQuietly ? true : data.quietReply,
+          publishedAt:
+            i === 0 ? data.publishedAt : (data.publishedAt ?? rootPublishedAt),
         };
 
         try {
@@ -1990,6 +2421,19 @@ export function createPostService(
 
       const nextTitle =
         data.title !== undefined ? data.title?.trim() || null : existing.title;
+      const effectiveNextVisibility = nextVisibility ?? existing.visibility;
+      const wasNavigationPageEligible =
+        existing.format === "note" &&
+        existing.status === "published" &&
+        existing.visibility !== "private" &&
+        !isThreadReply(existing) &&
+        hasNonEmptyText(existing.title);
+      const remainsNavigationPageEligible =
+        nextFormat === "note" &&
+        nextStatus === "published" &&
+        effectiveNextVisibility !== "private" &&
+        !isThreadReply(existing) &&
+        hasNonEmptyText(nextTitle);
 
       assertPostFormatShape({
         format: nextFormat,
@@ -2045,18 +2489,32 @@ export function createPostService(
       } else if (data.featured !== undefined) {
         updates.featuredAt = data.featured ? timestamp : null;
       }
+      // Same rule `create` enforces: nothing unpublished can be featured.
+      // Only guards turning it on — an existing flag survives a trip back to
+      // draft and takes effect again when the post is republished.
+      if (nextStatus === "draft" && updates.featuredAt) {
+        throw new ConflictError("Publish this post before featuring it.");
+      }
 
+      let updatedBody: string | null | undefined;
       if (data.body !== undefined || data.bodyMarkdown !== undefined) {
         const rawBody = data.bodyMarkdown
           ? markdownToTiptapJson(data.bodyMarkdown)
           : (data.body ?? null);
         const normalizedBody = rawBody ? trimTiptapBody(rawBody) : null;
-        updates.body = normalizedBody;
-        updates.bodyHtml = normalizedBody
-          ? renderTiptapJson(normalizedBody)
+        const preparedBody = normalizedBody
+          ? tryPreparePostBodyHtml(existing.id, normalizedBody)
           : null;
-        updates.bodyText = normalizedBody
-          ? extractBodyText(normalizedBody, { includeLinkHrefs: true })
+        updatedBody = preparedBody?.ok ? preparedBody.body : normalizedBody;
+        updates.body = updatedBody;
+        updates.bodyHtml = preparedBody?.ok
+          ? preparedBody.html
+          : updatedBody
+            ? renderPostBodyHtml(existing.id, updatedBody)
+            : null;
+        updates.bodyHtmlVersion = POST_BODY_HTML_VERSION;
+        updates.bodyText = updatedBody
+          ? extractBodyText(updatedBody, { includeLinkHrefs: true })
           : null;
       }
 
@@ -2064,14 +2522,7 @@ export function createPostService(
       if (summaryConfig) {
         const format = nextFormat;
         const title = nextTitle;
-        const body =
-          data.bodyMarkdown !== undefined
-            ? data.bodyMarkdown
-              ? markdownToTiptapJson(data.bodyMarkdown)
-              : null
-            : data.body !== undefined
-              ? data.body
-              : existing.body;
+        const body = updatedBody !== undefined ? updatedBody : existing.body;
         if (format === "note" && title && body) {
           updates.summary = extractSummary(
             body,
@@ -2128,14 +2579,24 @@ export function createPostService(
       const needsCascade = statusChanged && !isThreadReply(existing);
       const needsReplyVisibilityCleanup =
         !isThreadReply(existing) && (statusChanged || visibilityChanged);
-      const needsCollectionSync = data.collectionIds !== undefined;
-      const nextCollectionIds = needsCollectionSync
-        ? [...new Set(data.collectionIds ?? [])]
-        : [];
+      const needsCollectionSync =
+        data.collectionIds !== undefined ||
+        data.collectionEntries !== undefined;
       const needsThreadActivityRecalc =
         statusChanged || publishedAtChanged || existing.status === "draft";
+      const needsPageNavDelete =
+        wasNavigationPageEligible && !remainsNavigationPageEligible;
+      const needsPageNavUrlUpdate =
+        wasNavigationPageEligible &&
+        remainsNavigationPageEligible &&
+        slugChanged &&
+        Boolean(data.slug);
       const hasExtraWrites =
-        needsCascade || needsReplyVisibilityCleanup || needsCollectionSync;
+        needsCascade ||
+        needsReplyVisibilityCleanup ||
+        needsCollectionSync ||
+        needsPageNavDelete ||
+        needsPageNavUrlUpdate;
 
       if (!hasExtraWrites) {
         // Simple case: only the post update
@@ -2145,16 +2606,63 @@ export function createPostService(
           .where(and(eq(posts.siteId, siteId), eq(posts.id, id)))
           .returning();
         if (needsThreadActivityRecalc) {
-          await recalculateThreadLastActivity(existing.threadId);
+          await recalculateThreadActivity(existing.threadId);
           return this.getById(id);
         }
         return hydratePost(result[0]);
       }
 
-      // Complex case: cascade + update + collection sync atomically
-      const existingCollectionTimestamps = needsCollectionSync
-        ? await getPostCollectionTimestamps(id)
-        : new Map<string, number>();
+      // Complex case: cascade + update + Thread collection sync atomically.
+      // Retained entries keep their collected/pinned timestamps when a normal
+      // collectionIds update only changes selection or ordering.
+      const existingThreadCollections = needsCollectionSync
+        ? await getThreadCollectionEntries(existing.threadId)
+        : new Map<string, { createdAt: number; pinnedAt: number | null }>();
+      const collectionTimestamp = now();
+      const nextThreadCollectionRows = (() => {
+        if (!needsCollectionSync) return [];
+
+        if (data.collectionEntries !== undefined) {
+          const seen = new Set<string>();
+          return data.collectionEntries.flatMap((entry, index) => {
+            if (seen.has(entry.collectionId)) return [];
+            seen.add(entry.collectionId);
+            const existingEntry = existingThreadCollections.get(
+              entry.collectionId,
+            );
+            return [
+              {
+                siteId,
+                threadId: existing.threadId,
+                collectionId: entry.collectionId,
+                createdAt:
+                  entry.createdAt ??
+                  existingEntry?.createdAt ??
+                  collectionTimestamp,
+                position: entry.position ?? index,
+                pinnedAt:
+                  entry.pinnedAt !== undefined
+                    ? entry.pinnedAt
+                    : (existingEntry?.pinnedAt ?? null),
+              },
+            ];
+          });
+        }
+
+        return [...new Set(data.collectionIds ?? [])].map(
+          (collectionId, index) => {
+            const existingEntry = existingThreadCollections.get(collectionId);
+            return {
+              siteId,
+              threadId: existing.threadId,
+              collectionId,
+              createdAt: existingEntry?.createdAt ?? collectionTimestamp,
+              position: index,
+              pinnedAt: existingEntry?.pinnedAt ?? null,
+            };
+          },
+        );
+      })();
       let updateResult: (typeof posts.$inferSelect)[] | undefined;
 
       if (usesBatchWrites) {
@@ -2208,33 +2716,40 @@ export function createPostService(
             .returning(),
         );
 
+        if (needsPageNavDelete) {
+          writeQueries.push(
+            db
+              .delete(navItems)
+              .where(and(eq(navItems.siteId, siteId), eq(navItems.postId, id))),
+          );
+        } else if (needsPageNavUrlUpdate && data.slug) {
+          writeQueries.push(
+            db
+              .update(navItems)
+              .set({
+                url: `/${normalizePath(data.slug)}`,
+                updatedAt: timestamp,
+              })
+              .where(and(eq(navItems.siteId, siteId), eq(navItems.postId, id))),
+          );
+        }
+
         if (needsCollectionSync) {
-          // Delete all and re-insert to preserve user-specified ordering
+          // Delete all and re-insert the one shared Thread membership set.
           writeQueries.push(
             db
-              .delete(postCollections)
+              .delete(threadCollections)
               .where(
                 and(
-                  eq(postCollections.siteId, siteId),
-                  eq(postCollections.postId, id),
+                  eq(threadCollections.siteId, siteId),
+                  eq(threadCollections.threadId, existing.threadId),
                 ),
               ),
           );
 
-          if (nextCollectionIds.length > 0) {
-            const collectionTimestamp = now();
+          if (nextThreadCollectionRows.length > 0) {
             writeQueries.push(
-              db.insert(postCollections).values(
-                nextCollectionIds.map((collectionId, index) => ({
-                  siteId,
-                  postId: id,
-                  collectionId,
-                  createdAt:
-                    existingCollectionTimestamps.get(collectionId) ??
-                    collectionTimestamp,
-                  position: index,
-                })),
-              ),
+              db.insert(threadCollections).values(nextThreadCollectionRows),
             );
           }
         }
@@ -2291,37 +2806,42 @@ export function createPostService(
             .where(and(eq(posts.siteId, siteId), eq(posts.id, id)))
             .returning();
 
+          if (needsPageNavDelete) {
+            await tx
+              .delete(navItems)
+              .where(and(eq(navItems.siteId, siteId), eq(navItems.postId, id)));
+          } else if (needsPageNavUrlUpdate && data.slug) {
+            await tx
+              .update(navItems)
+              .set({
+                url: `/${normalizePath(data.slug)}`,
+                updatedAt: timestamp,
+              })
+              .where(and(eq(navItems.siteId, siteId), eq(navItems.postId, id)));
+          }
+
           if (needsCollectionSync) {
-            // Delete all and re-insert to preserve user-specified ordering
+            // Delete all and re-insert the one shared Thread membership set.
             await tx
-              .delete(postCollections)
+              .delete(threadCollections)
               .where(
                 and(
-                  eq(postCollections.siteId, siteId),
-                  eq(postCollections.postId, id),
+                  eq(threadCollections.siteId, siteId),
+                  eq(threadCollections.threadId, existing.threadId),
                 ),
               );
 
-            if (nextCollectionIds.length > 0) {
-              const collectionTimestamp = now();
-              await tx.insert(postCollections).values(
-                nextCollectionIds.map((collectionId, index) => ({
-                  siteId,
-                  postId: id,
-                  collectionId,
-                  createdAt:
-                    existingCollectionTimestamps.get(collectionId) ??
-                    collectionTimestamp,
-                  position: index,
-                })),
-              );
+            if (nextThreadCollectionRows.length > 0) {
+              await tx
+                .insert(threadCollections)
+                .values(nextThreadCollectionRows);
             }
           }
         });
       }
 
       if (needsThreadActivityRecalc) {
-        await recalculateThreadLastActivity(existing.threadId);
+        await recalculateThreadActivity(existing.threadId);
         return this.getById(id);
       }
       return hydratePost(updateResult?.[0]);
@@ -2360,7 +2880,9 @@ export function createPostService(
       const existingPost = await this.getById(id);
       if (!existingPost) return null;
 
-      const existingCollectionIds = await getCollectionIdsForPost(id);
+      const existingCollectionIds = await getCollectionIdsForThread(
+        existingPost.threadId,
+      );
       const rollbackData = buildRollbackUpdate(
         existingPost,
         existingCollectionIds,
@@ -2507,7 +3029,7 @@ export function createPostService(
         await db
           .delete(posts)
           .where(and(eq(posts.siteId, siteId), eq(posts.id, id)));
-        await recalculateThreadLastActivity(existing.threadId);
+        await recalculateThreadActivity(existing.threadId);
       }
 
       return true;
@@ -2527,6 +3049,44 @@ export function createPostService(
       return hydratePosts(rows);
     },
 
+    async getThreadPosition(postId) {
+      const targetRows = await db
+        .select({ replyToId: posts.replyToId, threadId: posts.threadId })
+        .from(posts)
+        .where(and(eq(posts.siteId, siteId), eq(posts.id, postId)))
+        .limit(1);
+
+      const target = targetRows[0];
+      if (!target) return 0;
+      if (!target.replyToId) return 1;
+
+      // One read for the whole Thread, then walk up in memory: a chain of N
+      // Posts would otherwise be N round trips.
+      const threadRows = await db
+        .select({ id: posts.id, replyToId: posts.replyToId })
+        .from(posts)
+        .where(
+          and(eq(posts.siteId, siteId), eq(posts.threadId, target.threadId)),
+        );
+
+      const parentOf = new Map(
+        threadRows.map((row) => [row.id, row.replyToId] as const),
+      );
+
+      let position = 1;
+      let cursor: string | null = target.replyToId;
+      // A cycle is impossible per the schema's CHECK constraints, but walking a
+      // parent chain unguarded turns a bad row into a hung request.
+      const visited = new Set<string>([postId]);
+      while (cursor && !visited.has(cursor)) {
+        visited.add(cursor);
+        position += 1;
+        cursor = parentOf.get(cursor) ?? null;
+      }
+
+      return position;
+    },
+
     async updateThreadStatusAndVisibility(rootId, status, visibility) {
       const nextStatus = ensurePostStatus(status);
       const nextVisibility = ensurePostVisibility(visibility);
@@ -2591,7 +3151,7 @@ export function createPostService(
             );
         });
       }
-      await recalculateThreadLastActivity(rootId);
+      await recalculateThreadActivity(rootId);
     },
 
     async getReplyCounts(postIds) {
@@ -2718,8 +3278,8 @@ export function createPostService(
         .from(rankedReplies)
         .where(
           or(
-            eq(rankedReplies.firstReplyRank, 1),
-            lte(rankedReplies.latestReplyRank, 2),
+            lte(rankedReplies.firstReplyRank, 2),
+            lte(rankedReplies.latestReplyRank, 3),
           ),
         );
 
@@ -2730,25 +3290,25 @@ export function createPostService(
       const contextByThreadId = new Map<
         string,
         {
-          secondReplyId: string | null;
-          penultimateReplyId: string | null;
+          leadingReplyIds: Map<number, string>;
+          trailingReplyIds: Map<number, string>;
           latestReplyId: string | null;
           totalReplyCount: number;
         }
       >();
       for (const row of contextRows) {
         const existing = contextByThreadId.get(row.threadId) ?? {
-          secondReplyId: null,
-          penultimateReplyId: null,
+          leadingReplyIds: new Map<number, string>(),
+          trailingReplyIds: new Map<number, string>(),
           latestReplyId: null,
           totalReplyCount: row.totalReplyCount,
         };
 
-        if (row.firstReplyRank === 1) {
-          existing.secondReplyId = row.id;
+        if (row.firstReplyRank <= 2) {
+          existing.leadingReplyIds.set(row.firstReplyRank, row.id);
         }
-        if (row.latestReplyRank === 2) {
-          existing.penultimateReplyId = row.id;
+        if (row.latestReplyRank === 2 || row.latestReplyRank === 3) {
+          existing.trailingReplyIds.set(row.latestReplyRank, row.id);
         }
         if (row.latestReplyRank === 1) {
           existing.latestReplyId = row.id;
@@ -2764,13 +3324,20 @@ export function createPostService(
         const latestReply = hydratedPosts.get(context.latestReplyId);
         if (!latestReply) continue;
 
+        const hydrateReplyIds = (ids: Array<string | undefined>) =>
+          ids
+            .map((id) => (id ? hydratedPosts.get(id) : undefined))
+            .filter((post): post is Post => post !== undefined);
+
         result.set(threadId, {
-          secondReply: context.secondReplyId
-            ? (hydratedPosts.get(context.secondReplyId) ?? null)
-            : null,
-          penultimateReply: context.penultimateReplyId
-            ? (hydratedPosts.get(context.penultimateReplyId) ?? null)
-            : null,
+          leadingReplies: hydrateReplyIds([
+            context.leadingReplyIds.get(1),
+            context.leadingReplyIds.get(2),
+          ]),
+          trailingReplies: hydrateReplyIds([
+            context.trailingReplyIds.get(3),
+            context.trailingReplyIds.get(2),
+          ]),
           latestReply,
           totalReplyCount: context.totalReplyCount,
         });
@@ -2803,19 +3370,20 @@ export function createPostService(
         ...buildThreadRootPageConditions(options),
         isNotNull(posts.featuredAt),
       ];
-      const latestFeaturedAt = sql<number>`MAX(${posts.featuredAt})`.as(
-        "latest_featured_at",
-      );
+      const latestFeaturedPublishedAt =
+        sql<number>`MAX(${posts.publishedAt})`.as(
+          "latest_featured_published_at",
+        );
 
       let query = db
         .select({
           threadId: posts.threadId,
-          latestFeaturedAt,
+          latestFeaturedPublishedAt,
         })
         .from(posts)
         .where(and(...conditions))
         .groupBy(posts.threadId)
-        .orderBy(desc(latestFeaturedAt), desc(posts.threadId));
+        .orderBy(desc(latestFeaturedPublishedAt), desc(posts.threadId));
 
       if (options.limit !== undefined) {
         query = query.limit(options.limit) as typeof query;
@@ -2828,6 +3396,77 @@ export function createPostService(
       return rows.map((row) => row.threadId);
     },
 
+    async getFeaturedThreadTimelineData(rootIds) {
+      const result = new Map<string, FeaturedThreadTimelineData>();
+      if (rootIds.length === 0) return result;
+
+      const uniqueRootIds = [...new Set(rootIds)];
+      const threadPosition = sql<number>`CAST(
+        row_number() OVER (
+          PARTITION BY ${posts.threadId}
+          ORDER BY ${posts.createdAt}, ${posts.id}
+        ) - 1 AS INTEGER
+      )`.as("thread_position");
+      const threadPostCount = sql<number>`CAST(
+        count(*) OVER (PARTITION BY ${posts.threadId}) AS INTEGER
+      )`.as("thread_post_count");
+
+      const rankedPosts = db
+        .select({
+          ...getTableColumns(posts),
+          threadPosition,
+          threadPostCount,
+        })
+        .from(posts)
+        .where(
+          and(
+            eq(posts.siteId, siteId),
+            inArray(posts.threadId, uniqueRootIds),
+            eq(posts.status, "published"),
+          ),
+        )
+        .as("ranked_featured_thread_post");
+
+      const rows = await db
+        .select()
+        .from(rankedPosts)
+        .where(
+          or(
+            eq(rankedPosts.id, rankedPosts.threadId),
+            isNotNull(rankedPosts.featuredAt),
+            sql`${rankedPosts.threadPosition} = ${rankedPosts.threadPostCount} - 1`,
+          ),
+        )
+        .orderBy(rankedPosts.threadId, sql`${rankedPosts.threadPosition}`);
+
+      const hydratedPosts = await hydratePosts(
+        rows.map(
+          ({ threadPosition: _position, threadPostCount: _count, ...row }) =>
+            row,
+        ),
+      );
+      const hydratedById = new Map(
+        hydratedPosts.map((post) => [post.id, post]),
+      );
+
+      for (const row of rows) {
+        const post = hydratedById.get(row.id);
+        if (!post) continue;
+
+        const thread = result.get(row.threadId) ?? {
+          posts: [],
+          featuredPostIds: [],
+        };
+        thread.posts.push({ post, position: row.threadPosition });
+        if (row.featuredAt !== null) {
+          thread.featuredPostIds.push(row.id);
+        }
+        result.set(row.threadId, thread);
+      }
+
+      return result;
+    },
+
     async countCollectionThreadRoots(collectionId, options = {}) {
       return this.countCollectionThreadRootsForCollections(
         [collectionId],
@@ -2853,10 +3492,10 @@ export function createPostService(
         })
         .from(posts)
         .innerJoin(
-          postCollections,
+          threadCollections,
           and(
-            eq(postCollections.siteId, siteId),
-            eq(postCollections.postId, posts.id),
+            eq(threadCollections.siteId, posts.siteId),
+            eq(threadCollections.threadId, posts.threadId),
           ),
         )
         .where(and(...conditions));
@@ -2864,6 +3503,35 @@ export function createPostService(
       return rows[0]?.count ?? 0;
     },
 
+    async countCollectionThreadRootsUpToForCollections(
+      collectionIds,
+      options = {},
+      limit,
+    ) {
+      const normalizedLimit = Math.max(0, Math.trunc(limit));
+      if (normalizedLimit === 0) return 0;
+
+      const conditions = [
+        ...buildThreadRootPageConditions(options),
+        buildCollectionMembershipCondition(collectionIds),
+      ];
+      const rows = await db
+        .select({ threadId: posts.threadId })
+        .from(posts)
+        .innerJoin(
+          threadCollections,
+          and(
+            eq(threadCollections.siteId, posts.siteId),
+            eq(threadCollections.threadId, posts.threadId),
+          ),
+        )
+        .where(and(...conditions))
+        .groupBy(posts.threadId)
+        .limit(normalizedLimit);
+
+      return rows.length;
+    },
+
     async listCollectionThreadRootIds(collectionId, options = {}) {
       return this.listCollectionThreadRootIdsForCollections(
         [collectionId],
@@ -2875,71 +3543,102 @@ export function createPostService(
       collectionIds,
       options = {},
     ) {
-      const conditions = [
-        ...buildThreadRootPageConditions(options),
-        buildCollectionMembershipCondition(collectionIds),
-      ];
-      const sortOrder = options.sortOrder ?? "newest";
-      const publishedAt =
-        sortOrder === "oldest"
-          ? sql<number>`MIN(${posts.publishedAt})`.as("published_at")
-          : sql<number>`MAX(${posts.publishedAt})`.as("published_at");
-      const threadActivityAt =
-        buildCollectionThreadActivityExpr("thread_activity_at");
-      const ratingPresence = sql<number>`MAX(
-        CASE
-          WHEN ${posts.rating} IS NULL THEN 0
-          ELSE 1
-        END
-      )`.as("rating_presence");
-      const ratingValue = sql<number | null>`MAX(${posts.rating})`.as(
-        "rating_value",
+      const { sortOrder, sortedThreads } = buildCollectionThreadSortQuery(
+        collectionIds,
+        options,
       );
+      let cursorCondition: SQL<unknown> | undefined;
+
+      if (options.cursor) {
+        const cursorRows = await db
+          .select()
+          .from(sortedThreads)
+          .where(eq(sortedThreads.threadId, options.cursor))
+          .limit(1);
+        const cursorRow = cursorRows[0];
+        if (!cursorRow) return [];
+
+        const pinnedKey: CursorSortKey = {
+          direction: "desc",
+          expr: sortedThreads.collectionPinnedAt,
+          value: cursorRow.collectionPinnedAt,
+        };
 
-      const collectionPinnedAt =
-        sql<number>`MAX(coalesce(${postCollections.pinnedAt}, -1))`.as(
-          "collection_pinned_at",
-        );
+        cursorCondition =
+          sortOrder === "oldest"
+            ? buildLexicographicCursorCondition([
+                pinnedKey,
+                {
+                  direction: "asc",
+                  expr: sortedThreads.publishedAt,
+                  value: cursorRow.publishedAt,
+                },
+                {
+                  direction: "asc",
+                  expr: sortedThreads.threadId,
+                  value: cursorRow.threadId,
+                },
+              ])
+            : sortOrder === "rating_desc"
+              ? buildLexicographicCursorCondition([
+                  pinnedKey,
+                  {
+                    direction: "desc",
+                    expr: sortedThreads.ratingPresence,
+                    value: cursorRow.ratingPresence,
+                  },
+                  {
+                    direction: "desc",
+                    expr: sortedThreads.ratingValue,
+                    value: cursorRow.ratingValue,
+                  },
+                  {
+                    direction: "desc",
+                    expr: sortedThreads.threadActivityAt,
+                    value: cursorRow.threadActivityAt,
+                  },
+                  {
+                    direction: "desc",
+                    expr: sortedThreads.threadId,
+                    value: cursorRow.threadId,
+                  },
+                ])
+              : buildLexicographicCursorCondition([
+                  pinnedKey,
+                  {
+                    direction: "desc",
+                    expr: sortedThreads.threadActivityAt,
+                    value: cursorRow.threadActivityAt,
+                  },
+                  {
+                    direction: "desc",
+                    expr: sortedThreads.threadId,
+                    value: cursorRow.threadId,
+                  },
+                ]);
+      }
 
-      const baseQuery = db
-        .select({
-          threadId: posts.threadId,
-          publishedAt,
-          threadActivityAt,
-          collectionPinnedAt,
-          ratingPresence,
-          ratingValue,
-        })
-        .from(posts)
-        .innerJoin(
-          postCollections,
-          and(
-            eq(postCollections.siteId, siteId),
-            eq(postCollections.postId, posts.id),
-          ),
-        )
-        .where(and(...conditions))
-        .groupBy(posts.threadId);
+      const baseQuery = db.select().from(sortedThreads).where(cursorCondition);
 
       let query =
         sortOrder === "oldest"
           ? baseQuery.orderBy(
-              desc(collectionPinnedAt),
-              asc(publishedAt),
-              asc(posts.threadId),
+              desc(sortedThreads.collectionPinnedAt),
+              asc(sortedThreads.publishedAt),
+              asc(sortedThreads.threadId),
             )
           : sortOrder === "rating_desc"
             ? baseQuery.orderBy(
-                desc(collectionPinnedAt),
-                desc(ratingPresence),
-                desc(ratingValue),
-                desc(threadActivityAt),
-                desc(posts.threadId),
+                desc(sortedThreads.collectionPinnedAt),
+                desc(sortedThreads.ratingPresence),
+                desc(sortedThreads.ratingValue),
+                desc(sortedThreads.threadActivityAt),
+                desc(sortedThreads.threadId),
               )
             : baseQuery.orderBy(
-                desc(collectionPinnedAt),
-                desc(threadActivityAt),
-                desc(posts.threadId),
+                desc(sortedThreads.collectionPinnedAt),
+                desc(sortedThreads.threadActivityAt),
+                desc(sortedThreads.threadId),
               );
 
       if (options.limit !== undefined) {
@@ -2953,6 +3652,18 @@ export function createPostService(
       return rows.map((row) => row.threadId);
     },
 
+    async listCollectionThreadRootsForCollections(collectionIds, options = {}) {
+      const rootIds = await this.listCollectionThreadRootIdsForCollections(
+        collectionIds,
+        options,
+      );
+      const rootsById = await hydratePostsById(rootIds);
+      return rootIds.flatMap((rootId) => {
+        const root = rootsById.get(rootId);
+        return root ? [root] : [];
+      });
+    },
+
     async listCollectionFeedEntries(collectionId, options = {}) {
       return this.listCollectionFeedEntriesForCollections(
         [collectionId],
@@ -2967,11 +3678,11 @@ export function createPostService(
       ];
       const threadActivityAt =
         buildCollectionThreadActivityExpr("thread_activity_at");
-      const collectedAt = sql<number>`MAX(${postCollections.createdAt})`.as(
+      const collectedAt = sql<number>`MAX(${threadCollections.createdAt})`.as(
         "collected_at",
       );
       const collectionPinnedAt =
-        sql<number>`MAX(coalesce(${postCollections.pinnedAt}, -1))`.as(
+        sql<number>`MAX(coalesce(${threadCollections.pinnedAt}, -1))`.as(
           "collection_pinned_at",
         );
       const pinnedOrder = options.ignoreCollectionPinnedSort
@@ -2987,10 +3698,10 @@ export function createPostService(
         })
         .from(posts)
         .innerJoin(
-          postCollections,
+          threadCollections,
           and(
-            eq(postCollections.siteId, siteId),
-            eq(postCollections.postId, posts.id),
+            eq(threadCollections.siteId, posts.siteId),
+            eq(threadCollections.threadId, posts.threadId),
           ),
         )
         .where(and(...conditions))
@@ -3013,21 +3724,23 @@ export function createPostService(
       });
     },
 
-    async getPublishedThreads(rootIds) {
+    async getPublishedThreads(rootIds, options = {}) {
       const result = new Map<string, Post[]>();
       if (rootIds.length === 0) return result;
 
       const unique = [...new Set(rootIds)];
+      const conditions = [
+        eq(posts.siteId, siteId),
+        inArray(posts.threadId, unique),
+        eq(posts.status, "published"),
+      ];
+      if (options.publishedBefore !== undefined) {
+        conditions.push(sql`${posts.publishedAt} < ${options.publishedBefore}`);
+      }
       const rows = await db
         .select()
         .from(posts)
-        .where(
-          and(
-            eq(posts.siteId, siteId),
-            inArray(posts.threadId, unique),
-            eq(posts.status, "published"),
-          ),
-        )
+        .where(and(...conditions))
         .orderBy(posts.threadId, posts.createdAt, posts.id);
 
       for (const post of await hydratePosts(rows)) {
@@ -3042,57 +3755,7 @@ export function createPostService(
       return result;
     },
 
-    async getCollectionPostIdsByThread(collectionId, threadIds) {
-      return this.getCollectionPostIdsByThreadForCollections(
-        [collectionId],
-        threadIds,
-      );
-    },
-
-    async getCollectionPostIdsByThreadForCollections(collectionIds, threadIds) {
-      const result = new Map<string, string[]>();
-      if (threadIds.length === 0) return result;
-
-      const unique = [...new Set(threadIds)];
-      const rows = await batchQueryRows(unique, (chunk) =>
-        db
-          .select({
-            threadId: posts.threadId,
-            postId: posts.id,
-          })
-          .from(posts)
-          .innerJoin(
-            postCollections,
-            and(
-              eq(postCollections.siteId, siteId),
-              eq(postCollections.postId, posts.id),
-            ),
-          )
-          .where(
-            and(
-              eq(posts.siteId, siteId),
-              buildCollectionMembershipCondition(collectionIds),
-              inArray(posts.threadId, chunk),
-              eq(posts.status, "published"),
-            ),
-          )
-          .groupBy(posts.threadId, posts.id)
-          .orderBy(posts.threadId, posts.createdAt, posts.id),
-      );
-
-      for (const row of rows) {
-        const list = result.get(row.threadId);
-        if (list) {
-          list.push(row.postId);
-        } else {
-          result.set(row.threadId, [row.postId]);
-        }
-      }
-
-      return result;
-    },
-
-    async getLastPostIdsByThread(threadIds) {
+    async getThreadTailIds(threadIds, options) {
       const result = new Map<string, string>();
       if (threadIds.length === 0) return result;
 
@@ -3107,7 +3770,7 @@ export function createPostService(
           and(
             eq(posts.siteId, siteId),
             inArray(posts.threadId, unique),
-            eq(posts.status, "published"),
+            ...(options?.includeDrafts ? [] : [eq(posts.status, "published")]),
           ),
         )
         .orderBy(posts.threadId, desc(posts.createdAt), desc(posts.id));
@@ -3121,11 +3784,9 @@ export function createPostService(
     },
 
     async getDistinctYears(filters = {}) {
-      const conditions = [
-        ...buildFilterConditions(filters),
-        isNotNull(posts.publishedAt),
-      ];
-      const publishedYearExpr = buildPublishedYearExpr();
+      const axis = timeAxisColumn(filters);
+      const conditions = [...buildFilterConditions(filters), isNotNull(axis)];
+      const publishedYearExpr = buildYearExpr(axis);
 
       const rows = await db
         .select({
@@ -3191,5 +3852,144 @@ export function createPostService(
         done: !hasMore,
       };
     },
+
+    async rebuildBodyHtml(options = {}) {
+      const requested = options.limit ?? 50;
+      const limit = Math.min(Math.max(Math.trunc(requested), 1), 100);
+      const cursor = options.cursor;
+      const dryRun = options.dryRun ?? false;
+
+      const siteRows = await db
+        .select({ id: sites.id })
+        .from(sites)
+        .where(eq(sites.id, siteId))
+        .limit(1);
+      if (!siteRows[0]) {
+        throw new NotFoundError("Site");
+      }
+
+      const whereConditions = [eq(posts.siteId, siteId)];
+      if (cursor) whereConditions.push(gt(posts.id, cursor));
+
+      const rows = await db
+        .select({
+          id: posts.id,
+          format: posts.format,
+          title: posts.title,
+          body: posts.body,
+          bodyHtml: posts.bodyHtml,
+          bodyHtmlVersion: posts.bodyHtmlVersion,
+        })
+        .from(posts)
+        .where(and(...whereConditions))
+        .orderBy(asc(posts.id))
+        .limit(limit + 1);
+
+      const hasMore = rows.length > limit;
+      const batch = hasMore ? rows.slice(0, limit) : rows;
+      const failures: Array<{ postId: string; error: string }> = [];
+      let wouldRebuild = 0;
+      let rebuilt = 0;
+      let wouldUpgradeFootnotes = 0;
+      let upgradedFootnotes = 0;
+      let skipped = 0;
+      let conflicted = 0;
+
+      for (const row of batch) {
+        if (row.bodyHtmlVersion > POST_BODY_HTML_VERSION) {
+          skipped++;
+          continue;
+        }
+
+        let nextBody = row.body;
+        let nextBodyHtml: string | null = null;
+        let upgradesLegacyFootnotes = false;
+        if (row.body !== null) {
+          const prepared = tryPreparePostBodyHtml(row.id, row.body);
+          if (!prepared.ok) {
+            failures.push({ postId: row.id, error: prepared.error });
+            continue;
+          }
+          nextBody = prepared.body;
+          nextBodyHtml = prepared.html;
+          upgradesLegacyFootnotes = prepared.upgradedLegacyFootnotes;
+        }
+
+        if (
+          row.bodyHtmlVersion === POST_BODY_HTML_VERSION &&
+          row.body === nextBody &&
+          row.bodyHtml === nextBodyHtml
+        ) {
+          skipped++;
+          continue;
+        }
+
+        wouldRebuild++;
+        if (upgradesLegacyFootnotes) wouldUpgradeFootnotes++;
+        if (dryRun) continue;
+
+        const bodyCondition =
+          row.body === null ? isNull(posts.body) : eq(posts.body, row.body);
+        const canonicalBodyChanged = row.body !== nextBody;
+        const updates: Partial<typeof posts.$inferInsert> = {
+          bodyHtml: nextBodyHtml,
+          bodyHtmlVersion: POST_BODY_HTML_VERSION,
+        };
+        if (canonicalBodyChanged) {
+          updates.body = nextBody;
+          updates.bodyText = nextBody
+            ? extractBodyText(nextBody, { includeLinkHrefs: true })
+            : null;
+
+          if (options.summaryConfig) {
+            updates.summary =
+              row.format === "note" && row.title && nextBody
+                ? extractSummary(
+                    nextBody,
+                    options.summaryConfig.maxParagraphs,
+                    options.summaryConfig.maxChars,
+                  )
+                : null;
+          }
+        }
+        const updatedRows = await db
+          .update(posts)
+          .set(updates)
+          .where(
+            and(
+              eq(posts.siteId, siteId),
+              eq(posts.id, row.id),
+              bodyCondition,
+              eq(posts.bodyHtmlVersion, row.bodyHtmlVersion),
+            ),
+          )
+          .returning({ id: posts.id });
+
+        if (updatedRows.length === 0) {
+          conflicted++;
+        } else {
+          rebuilt++;
+          if (upgradesLegacyFootnotes) upgradedFootnotes++;
+        }
+      }
+
+      const lastRow = batch.at(-1);
+      const lastId = lastRow ? lastRow.id : null;
+
+      return {
+        processed: batch.length,
+        wouldRebuild,
+        rebuilt,
+        wouldUpgradeFootnotes,
+        upgradedFootnotes,
+        skipped,
+        conflicted,
+        failed: failures.length,
+        failures,
+        nextCursor: hasMore ? lastId : null,
+        done: !hasMore,
+        targetVersion: POST_BODY_HTML_VERSION,
+      };
+    },
   };
 }