@jant/core 0.6.15 → 0.6.16

package/src/services/post.ts

@@ -32,6 +32,10 @@ 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 { trimTiptapBody } from "../lib/tiptap-render.js";
@@ -141,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 */
@@ -156,8 +168,20 @@ export interface PostFilters {
   hasReplies?: boolean;
   /** Explicit result sort order */
   sortOrder?: SortOrder;
-  /** Timestamp used for chronological sorting (defaults to thread activity). */
-  sortBy?: "activity" | "published";
+  /**
+   * 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;
@@ -289,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 }[]>;
@@ -346,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,
@@ -416,10 +455,31 @@ export interface PostService {
     rootIds: string[],
     options?: Pick<PostFilters, "publishedBefore">,
   ): Promise<Map<string, Post[]>>;
-  /** Get distinct years that have published posts */
+  /** 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
@@ -640,16 +700,27 @@ export function createPostService(
   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(
@@ -690,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)));
   }
 
@@ -887,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(
@@ -899,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) {
@@ -946,19 +1050,6 @@ 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,
@@ -966,9 +1057,33 @@ export function createPostService(
     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);
   }
 
+  /**
+   * 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(
     keys: [CursorSortKey, ...CursorSortKey[]],
   ): SQL<unknown> {
@@ -1008,17 +1123,7 @@ export function createPostService(
       return null;
     }
 
-    const sortTimestampExpr =
-      filters.sortBy === "published"
-        ? sql<number>`coalesce(${posts.publishedAt}, ${posts.createdAt})`
-        : 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 featuredPublishedSortExpr = sql<number>`coalesce(
       ${posts.publishedAt}, ${posts.createdAt}, -1
@@ -1153,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,
     };
@@ -1284,16 +1395,19 @@ export function createPostService(
     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 CASE
-            WHEN root.updated_at > root.created_at
-              AND root.updated_at > COALESCE(root.last_activity_at, -1)
-            THEN root.updated_at
-            ELSE COALESCE(root.last_activity_at, root.updated_at)
-          END
+          SELECT ${buildRootActivityExpr(rootActivityColumns("root"))}
           FROM post AS root
           WHERE root.site_id = ${siteId}
             AND root.id = ${posts.threadId}
@@ -1553,17 +1667,7 @@ export function createPostService(
       if (filters.cursor && !cursorCondition) {
         return [];
       }
-      const sortTimestamp =
-        filters.sortBy === "published"
-          ? sql<number>`coalesce(${posts.publishedAt}, ${posts.createdAt})`
-          : 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);
@@ -1645,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)
@@ -1738,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({
@@ -1766,6 +1888,8 @@ 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)
@@ -1846,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.",
           );
         }
 
@@ -1860,10 +1993,12 @@ 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;
 
@@ -1877,6 +2012,12 @@ export function createPostService(
         }
       }
 
+      // 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);
       const publishedAt =
         status === "published" ? (data.publishedAt ?? timestamp) : null;
@@ -2006,8 +2147,10 @@ export function createPostService(
               rating,
               replyToId: data.replyToId ?? null,
               threadId,
+              quietReply: isQuietReply,
               publishedAt,
               lastActivityAt: publishedAt ?? timestamp,
+              threadUpdatedAt: publishedAt ?? timestamp,
               createdAt: timestamp,
               updatedAt: timestamp,
             }),
@@ -2083,8 +2226,10 @@ export function createPostService(
               rating,
               replyToId: data.replyToId ?? null,
               threadId,
+              quietReply: isQuietReply,
               publishedAt,
               lastActivityAt: publishedAt ?? timestamp,
+              threadUpdatedAt: publishedAt ?? timestamp,
               createdAt: timestamp,
               updatedAt: timestamp,
             });
@@ -2144,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;
@@ -2208,11 +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 {
@@ -2334,6 +2489,12 @@ 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) {
@@ -2445,7 +2606,7 @@ 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]);
@@ -2680,7 +2841,7 @@ export function createPostService(
       }
 
       if (needsThreadActivityRecalc) {
-        await recalculateThreadLastActivity(existing.threadId);
+        await recalculateThreadActivity(existing.threadId);
         return this.getById(id);
       }
       return hydratePost(updateResult?.[0]);
@@ -2868,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;
@@ -2888,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);
@@ -2952,7 +3151,7 @@ export function createPostService(
             );
         });
       }
-      await recalculateThreadLastActivity(rootId);
+      await recalculateThreadActivity(rootId);
     },
 
     async getReplyCounts(postIds) {
@@ -3556,7 +3755,7 @@ export function createPostService(
       return result;
     },
 
-    async getLastPostIdsByThread(threadIds) {
+    async getThreadTailIds(threadIds, options) {
       const result = new Map<string, string>();
       if (threadIds.length === 0) return result;
 
@@ -3571,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));
@@ -3585,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({