@jant/core 0.3.40 → 0.3.43

package/src/services/post.ts

@@ -9,6 +9,7 @@
 import {
   eq,
   and,
+  or,
   type SQL,
   type SQLWrapper,
   isNull,
@@ -18,6 +19,7 @@ import {
   isNotNull,
   asc,
   lte,
+  gt,
 } from "drizzle-orm";
 import {
   type Database,
@@ -31,9 +33,10 @@ import {
 } from "../db/schema-bundle.js";
 import { createEntityId } from "../lib/ids.js";
 import { now } from "../lib/time.js";
-import { renderTiptapJson } from "../lib/tiptap-render.js";
+import { renderTiptapJson, trimTiptapBody } from "../lib/tiptap-render.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 { normalizePath, slugify } from "../lib/url.js";
@@ -64,6 +67,12 @@ import {
   NotFoundError,
 } from "../lib/errors.js";
 import { createPathService, type PathService } from "./path.js";
+import {
+  extractYouTubeVideoId,
+  getYouTubeThumbnailUrls,
+} from "../lib/youtube.js";
+import { getPreviewStorageKey } from "../lib/upload.js";
+import { generateRandomId } from "../lib/nanoid.js";
 
 /** Dependencies for operations that coordinate with other services */
 export interface PostDeleteDeps {
@@ -139,8 +148,29 @@ export interface CollectionFeedEntry {
   collectedAt: number;
 }
 
+export interface PostBodyContent {
+  id: string;
+  type: "post";
+  format: Format;
+  contentFormat: "markdown";
+  content: string;
+  chars: number;
+}
+
+/** Minimal projection used by the sitemap renderer. */
+export interface SitemapPostEntry {
+  id: string;
+  /** Canonical slug from `path_registry` */
+  slug: string;
+  /** Primary alias, if the post has one; used in preference to `slug` for URLs */
+  alias: string | null;
+  updatedAt: number;
+  featuredAt: number | null;
+}
+
 export interface PostService {
   getById(id: string): Promise<Post | null>;
+  getBodyContent(id: string): Promise<PostBodyContent | null>;
   getBySlug(slug: string): Promise<Post | null>;
   suggestSlug(input: {
     title?: string;
@@ -149,6 +179,35 @@ export interface PostService {
   }): Promise<string>;
   checkSlugAvailability(slug: string, excludePostId?: string): Promise<boolean>;
   list(filters?: PostFilters): Promise<Post[]>;
+  /**
+   * List minimal fields needed to render sitemap entries, paginated by `id`
+   * (ascending). Excludes replies, private posts, deleted posts, and drafts.
+   *
+   * Uses keyset pagination on the primary key so old sitemap shards are cheap
+   * to serve and stable across shard boundaries: a newly created post always
+   * gets a larger TypeID than any previously-committed post, so it lands in
+   * the last shard and never rewrites older ones.
+   *
+   * @param options.afterId  Exclusive lower bound on `id`. Omit for the first
+   *                         shard.
+   * @param options.limit    Maximum rows to return.
+   */
+  listForSitemap(options: {
+    afterId?: string;
+    limit: number;
+  }): Promise<SitemapPostEntry[]>;
+  /** Count posts that qualify for the sitemap (same filters as `listForSitemap`) */
+  countForSitemap(): Promise<number>;
+  /**
+   * Return the id at the given 0-based offset in the sitemap ordering.
+   * Used to compute keyset cursors for sharded sitemap endpoints.
+   *
+   * Returns `null` when the offset is beyond the available rows.
+   *
+   * Walks the primary-key index with `ORDER BY id ASC LIMIT 1 OFFSET ?` —
+   * SQLite/D1 scan only the index for this, not the row data.
+   */
+  getSitemapIdAt(offset: number): Promise<string | null>;
   /** Count posts matching filters (ignores cursor, offset, limit) */
   count(filters?: PostFilters): Promise<number>;
   /** Count posts matching filters up to a fixed limit (ignores cursor, offset, limit) */
@@ -164,6 +223,24 @@ export interface PostService {
     deps: PostAttachmentDeps,
     summaryConfig?: SummaryConfig,
   ): Promise<Post>;
+  /**
+   * 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.
+   * On failure, all already-created posts are rolled back.
+   *
+   * @param items - Ordered list of (data, attachments) pairs; at least 2 required
+   * @param deps - Media/storage dependencies
+   * @param summaryConfig - Optional summary extraction config
+   * @returns Ordered list of created posts; posts[0] is the root
+   */
+  createThreadWithAttachments(
+    items: Array<{
+      data: CreatePost;
+      attachments: PostAttachmentInput[] | undefined;
+    }>,
+    deps: PostAttachmentDeps,
+    summaryConfig?: SummaryConfig,
+  ): Promise<Post[]>;
   update(
     id: string,
     data: UpdatePost,
@@ -184,6 +261,11 @@ export interface PostService {
    * @param deps - Media service and optional storage driver for file cleanup
    */
   delete(id: string, deps?: PostDeleteDeps): Promise<boolean>;
+  /**
+   * Delete a thread draft and release its slug paths so they can be reused.
+   * Used when replacing a saved thread draft with a new version.
+   */
+  deleteThreadDraft(id: string, deps?: PostDeleteDeps): Promise<boolean>;
   getThread(rootId: string): Promise<Post[]>;
   updateThreadStatusAndVisibility(
     rootId: string,
@@ -251,6 +333,28 @@ export interface PostService {
   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>>;
+  /**
+   * 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
+   * `extractBodyText(body)` and writes it back only when it differs from the
+   * stored value. FTS indexes (SQLite trigger / Postgres generated column)
+   * refresh automatically on the UPDATE.
+   *
+   * Idempotent: re-running after a no-op pass returns `updated: 0`.
+   *
+   * @param options.limit  Batch size (1..500, default 50)
+   * @param options.cursor Exclusive lower bound on post id; pass the previous
+   *                       response's `nextCursor` to continue
+   * @returns processed/updated/skipped counts, the next cursor, and a `done`
+   *          flag the caller uses to terminate the loop
+   */
+  reindexBodyText(options?: { limit?: number; cursor?: string }): Promise<{
+    processed: number;
+    updated: number;
+    skipped: number;
+    nextCursor: string | null;
+    done: boolean;
+  }>;
 }
 
 const SLUG_RE = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
@@ -259,24 +363,8 @@ function isValidSlug(value: string): boolean {
   return SLUG_RE.test(value);
 }
 
-/** Check if an error (or any of its causes) is a SQLite UNIQUE constraint violation */
-function isUniqueConstraintError(err: unknown): boolean {
-  let current: unknown = err;
-  while (current) {
-    const msg = String(current);
-    if (
-      msg.includes("UNIQUE constraint") ||
-      msg.includes("SQLITE_CONSTRAINT")
-    ) {
-      return true;
-    }
-    current =
-      current instanceof Error && current.cause !== current
-        ? current.cause
-        : undefined;
-  }
-  return false;
-}
+// Re-export shared constraint detection — see db/dialect.ts
+import { isUniqueConstraintError } from "../db/dialect.js";
 
 function hasNonEmptyText(value: string | null | undefined): boolean {
   return typeof value === "string" && value.trim().length > 0;
@@ -349,8 +437,10 @@ function ensurePostRating(
 function assertPostFormatShape(data: {
   format: Format;
   title?: string | null;
+  body?: unknown;
   url?: string | null;
   quoteText?: string | null;
+  hasAttachments?: boolean;
 }): void {
   const hasTitle = hasNonEmptyText(data.title);
   const hasUrl = hasNonEmptyText(data.url);
@@ -363,6 +453,18 @@ function assertPostFormatShape(data: {
     if (hasQuoteText) {
       throw new ValidationError("Notes can't include quoted text.");
     }
+    // hasAttachments === undefined means unknown (e.g. update without
+    // attachment changes) — skip the empty-content check in that case.
+    if (
+      !hasTitle &&
+      !data.body &&
+      data.hasAttachments !== undefined &&
+      !data.hasAttachments
+    ) {
+      throw new ValidationError(
+        "Notes need a title, body, or at least one attachment.",
+      );
+    }
     return;
   }
 
@@ -497,6 +599,87 @@ export function createPostService(
     return [...new Set(collectionIds)];
   }
 
+  /**
+   * Fetch a link preview thumbnail and store it.
+   * Silently returns without updating if the URL is not a recognized provider
+   * or if the fetch fails.
+   */
+  async function resolveAndStorePreview(
+    postId: string,
+    format: string,
+    url: string | null | undefined,
+    storage: StorageDriver | null | undefined,
+  ): Promise<void> {
+    if (!storage || format !== "link" || !url) return;
+
+    const videoId = extractYouTubeVideoId(url);
+    if (!videoId) return;
+
+    const thumbnailUrls = getYouTubeThumbnailUrls(videoId);
+    let imageBytes: Uint8Array | null = null;
+    let contentType = "image/jpeg";
+
+    for (const thumbUrl of thumbnailUrls) {
+      try {
+        const response = await fetch(thumbUrl);
+        if (response.ok) {
+          const ct = response.headers.get("content-type");
+          // YouTube returns a grey placeholder (120×90) when maxresdefault
+          // is not available. Detect it by checking content-length.
+          const cl = response.headers.get("content-length");
+          if (cl && parseInt(cl, 10) < 5000) {
+            // Too small — likely a placeholder, try next quality
+            continue;
+          }
+          imageBytes = new Uint8Array(await response.arrayBuffer());
+          if (ct) contentType = ct;
+          break;
+        }
+      } catch {
+        // Network failure — try next URL
+      }
+    }
+
+    if (!imageBytes) return;
+
+    const ext = contentType.includes("webp")
+      ? "webp"
+      : contentType.includes("png")
+        ? "png"
+        : "jpg";
+    const suffix = generateRandomId(8);
+    const storageKey = getPreviewStorageKey(siteId, postId, suffix, ext);
+
+    try {
+      await storage.put(storageKey, imageBytes, { contentType });
+      await db
+        .update(posts)
+        .set({
+          previewImageKey: storageKey,
+          previewKind: "video",
+          previewProvider: "youtube",
+        })
+        .where(and(eq(posts.siteId, siteId), eq(posts.id, postId)));
+    } catch {
+      // Storage or DB failure — preview is best-effort
+    }
+  }
+
+  /**
+   * Delete a preview image from storage if it exists.
+   */
+  async function deletePreviewImage(
+    previewImageKey: string | null | undefined,
+    storage: StorageDriver | null | undefined,
+  ): Promise<void> {
+    if (!storage || !previewImageKey) return;
+    try {
+      await storage.delete(previewImageKey);
+    } catch {
+      // Best-effort cleanup
+    }
+  }
+
   function buildCollectionMembershipCondition(
     collectionIds: readonly string[],
   ): SQL<unknown> {
@@ -631,6 +814,25 @@ 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),
+          isNull(posts.deletedAt),
+        ),
+      )
+      .orderBy(desc(posts.createdAt), desc(posts.id))
+      .limit(1);
+
+    return rows[0]?.id ?? null;
+  }
+
   function getCursorSortTimestamp(row: typeof posts.$inferSelect): number {
     return row.status === "draft" ? row.updatedAt : (row.lastActivityAt ?? -1);
   }
@@ -790,6 +992,9 @@ export function createPostService(
       quoteText: row.quoteText,
       summary: row.summary,
       rating: ensurePostRating(row.rating, Error),
+      previewImageKey: row.previewImageKey,
+      previewKind: row.previewKind,
+      previewProvider: row.previewProvider,
       replyToId: row.replyToId,
       threadId: row.threadId,
       deletedAt: row.deletedAt,
@@ -981,6 +1186,24 @@ export function createPostService(
     return rows.map((row) => row.collectionId);
   }
 
+  async function getPostCollectionTimestamps(
+    postId: string,
+  ): Promise<Map<string, number>> {
+    const rows = await db
+      .select({
+        collectionId: postCollections.collectionId,
+        createdAt: postCollections.createdAt,
+      })
+      .from(postCollections)
+      .where(
+        and(
+          eq(postCollections.siteId, siteId),
+          eq(postCollections.postId, postId),
+        ),
+      );
+    return new Map(rows.map((r) => [r.collectionId, r.createdAt]));
+  }
+
   function buildRollbackUpdate(
     post: Post,
     collectionIds: string[],
@@ -1018,6 +1241,20 @@ export function createPostService(
       return hydratePost(result[0]);
     },
 
+    async getBodyContent(id) {
+      const post = await this.getById(id);
+      if (!post) return null;
+
+      return {
+        id: post.id,
+        type: "post",
+        format: post.format,
+        contentFormat: "markdown",
+        content: post.body ? tiptapJsonToMarkdown(post.body) : "",
+        chars: post.bodyText?.length ?? 0,
+      };
+    },
+
     async getBySlug(slug) {
       const resolved = await resolvedPaths.resolve(slug);
       if (!resolved || resolved.kind !== "slug" || !resolved.postId) {
@@ -1073,6 +1310,14 @@ export function createPostService(
           ELSE 1
         END`;
 
+      // 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
+      // expressions used by `buildListCursorCondition` above.
+      const pinnedSortExpr = sql<number>`coalesce(${posts.pinnedAt}, -1)`;
+      const featuredSortExpr = sql<number>`coalesce(${posts.featuredAt}, -1)`;
+      const sortTimestampSortExpr = sql<number>`coalesce(${sortTimestamp}, -1)`;
+
       const baseQuery = db
         .select()
         .from(posts)
@@ -1082,29 +1327,31 @@ export function createPostService(
       let query =
         filters.featured || filters.sortOrder === undefined
           ? baseQuery.orderBy(
-              desc(posts.pinnedAt),
-              filters.featured ? desc(posts.featuredAt) : desc(sortTimestamp),
+              desc(pinnedSortExpr),
+              filters.featured
+                ? desc(featuredSortExpr)
+                : desc(sortTimestampSortExpr),
               desc(posts.id),
             )
           : filters.sortOrder === "oldest"
             ? baseQuery.orderBy(
-                desc(posts.pinnedAt),
-                asc(sortTimestamp),
+                desc(pinnedSortExpr),
+                asc(sortTimestampSortExpr),
                 asc(posts.id),
               )
             : filters.sortOrder === "rating_desc"
               ? baseQuery.orderBy(
-                  desc(posts.pinnedAt),
+                  desc(pinnedSortExpr),
                   desc(ratingPresence),
                   desc(posts.rating),
-                  desc(sortTimestamp),
+                  desc(sortTimestampSortExpr),
                   desc(posts.id),
                 )
               : baseQuery.orderBy(
-                  desc(posts.pinnedAt),
+                  desc(pinnedSortExpr),
                   desc(ratingPresence),
                   asc(posts.rating),
-                  desc(sortTimestamp),
+                  desc(sortTimestampSortExpr),
                   desc(posts.id),
                 );
 
@@ -1116,11 +1363,88 @@ export function createPostService(
       return hydratePosts(rows);
     },
 
+    async listForSitemap({ afterId, limit }) {
+      // Share the filter conditions with `list()` so visibility/reply/deleted
+      // semantics stay consistent if they ever change.
+      const conditions = buildFilterConditions({
+        status: "published",
+        excludePrivate: true,
+        excludeReplies: true,
+      });
+      if (afterId !== undefined) {
+        conditions.push(sql`${posts.id} > ${afterId}`);
+      }
+
+      const rows = await db
+        .select({
+          id: posts.id,
+          updatedAt: posts.updatedAt,
+          featuredAt: posts.featuredAt,
+        })
+        .from(posts)
+        .where(conditions.length > 0 ? and(...conditions) : undefined)
+        .orderBy(asc(posts.id))
+        .limit(limit);
+
+      if (rows.length === 0) return [];
+
+      const ids = rows.map((row) => row.id);
+      const [slugMap, aliasesMap] = await Promise.all([
+        resolvedPaths.getPostSlugMap(ids),
+        resolvedPaths.getPostAliases(ids),
+      ]);
+
+      return rows
+        .map((row): SitemapPostEntry | null => {
+          const slug = slugMap.get(row.id);
+          if (!slug) return null;
+          const alias = aliasesMap.get(row.id)?.[0] ?? null;
+          return {
+            id: row.id,
+            slug,
+            alias,
+            updatedAt: row.updatedAt,
+            featuredAt: row.featuredAt,
+          };
+        })
+        .filter((entry): entry is SitemapPostEntry => entry !== null);
+    },
+
+    async countForSitemap() {
+      const conditions = buildFilterConditions({
+        status: "published",
+        excludePrivate: true,
+        excludeReplies: true,
+      });
+      const result = await db
+        .select({ count: sql<number>`CAST(count(*) AS INTEGER)`.as("count") })
+        .from(posts)
+        .where(conditions.length > 0 ? and(...conditions) : undefined);
+      return result[0]?.count ?? 0;
+    },
+
+    async getSitemapIdAt(offset) {
+      if (offset < 0) return null;
+      const conditions = buildFilterConditions({
+        status: "published",
+        excludePrivate: true,
+        excludeReplies: true,
+      });
+      const rows = await db
+        .select({ id: posts.id })
+        .from(posts)
+        .where(conditions.length > 0 ? and(...conditions) : undefined)
+        .orderBy(asc(posts.id))
+        .limit(1)
+        .offset(offset);
+      return rows[0]?.id ?? null;
+    },
+
     async count(filters = {}) {
       const conditions = buildFilterConditions(filters);
 
       const result = await db
-        .select({ count: sql<number>`count(*)`.as("count") })
+        .select({ count: sql<number>`CAST(count(*) AS INTEGER)`.as("count") })
         .from(posts)
         .where(conditions.length > 0 ? and(...conditions) : undefined);
 
@@ -1153,7 +1477,7 @@ export function createPostService(
       return db
         .select({
           yearMonth: publishedYearMonthExpr.as("year_month"),
-          count: sql<number>`count(*)`.as("count"),
+          count: sql<number>`CAST(count(*) AS INTEGER)`.as("count"),
         })
         .from(posts)
         .where(conditions.length > 0 ? and(...conditions) : undefined)
@@ -1173,22 +1497,33 @@ export function createPostService(
           : undefined;
       const rating = ensurePostRating(data.rating);
 
+      const rawBody = data.bodyMarkdown
+        ? markdownToTiptapJson(data.bodyMarkdown)
+        : (data.body ?? null);
+      const body = rawBody ? trimTiptapBody(rawBody) : null;
+      const title = data.title?.trim() || null;
+      const quoteText = data.quoteText?.trim() || null;
+      const url = data.url?.trim() || null;
+
       assertPostFormatShape({
         format,
-        title: data.title,
-        url: data.url,
-        quoteText: data.quoteText,
+        title,
+        body,
+        url,
+        quoteText,
+        hasAttachments: data.attachments
+          ? data.attachments.length > 0
+          : undefined,
       });
 
-      const body = data.bodyMarkdown
-        ? markdownToTiptapJson(data.bodyMarkdown)
-        : (data.body ?? null);
       const bodyHtml = body ? renderTiptapJson(body) : null;
-      const bodyText = body ? extractBodyText(body) : null;
+      const bodyText = body
+        ? extractBodyText(body, { includeLinkHrefs: true })
+        : null;
 
       // Generate summary for titled notes with body content
       let summary: string | null = null;
-      if (format === "note" && data.title && body && summaryConfig) {
+      if (format === "note" && title && body && summaryConfig) {
         summary = extractSummary(
           body,
           summaryConfig.maxParagraphs,
@@ -1201,18 +1536,45 @@ export function createPostService(
       let status: Status = requestedStatus ?? "published";
       let visibility: Visibility | null = requestedVisibility ?? "public";
 
+      // Collapse the two-input (`flag` + `flagAt`) pair the DTO exposes
+      // into the single timestamp form the DB column stores. Explicit
+      // `*At` wins over the boolean shorthand when both are set.
+      const resolvedPinnedAt =
+        data.pinnedAt !== undefined
+          ? data.pinnedAt
+          : data.pinned !== undefined
+            ? data.pinned
+              ? timestamp
+              : null
+            : null;
+      const resolvedFeaturedAt =
+        data.featuredAt !== undefined
+          ? data.featuredAt
+          : data.featured !== undefined
+            ? data.featured
+              ? timestamp
+              : null
+            : null;
+
       if (data.replyToId) {
         const parent = await this.getById(data.replyToId);
         if (!parent) {
           throw new NotFoundError("Parent post");
         }
 
-        if (data.pinned) {
+        if (resolvedPinnedAt !== null) {
           throw new ConflictError(
             "Cannot pin a thread reply. Pin the root post instead.",
           );
         }
 
+        const lastLivePostId = await getLastLivePostIdInThread(parent.threadId);
+        if (lastLivePostId && lastLivePostId !== parent.id) {
+          throw new ConflictError(
+            "This post is no longer the end of the thread. Reply to the latest post instead.",
+          );
+        }
+
         threadId = parent.threadId;
 
         // Replies inherit visibility from the root at read time.
@@ -1236,6 +1598,14 @@ export function createPostService(
       let slug: string;
       let aliasPath: string | null = null;
 
+      // Quote `title` stores source attribution (e.g. author name), not a real
+      // title — deriving the slug from it would produce URLs like `/basho`
+      // that read as "a page about Basho" and collide across every quote from
+      // the same source. Fall through to random IDs instead; users who want a
+      // readable slug can still set one explicitly.
+      const titleForSlug =
+        format === "quote" ? undefined : (title ?? undefined);
+
       if (data.path) {
         const normalized = normalizePath(data.path);
         if (isValidSlug(normalized)) {
@@ -1250,7 +1620,7 @@ export function createPostService(
           const slugified = slugify(normalized);
           slug = await generatePostSlug({
             slug: slugified || undefined,
-            title: data.title,
+            title: titleForSlug,
             idLength: config.slugIdLength,
             isAvailable: isSlugAvailable,
           });
@@ -1263,13 +1633,61 @@ export function createPostService(
       } else {
         slug = await generatePostSlug({
           slug: data.slug,
-          title: data.title,
+          title: titleForSlug,
           idLength: config.slugIdLength,
           isAvailable: isSlugAvailable,
         });
       }
 
-      const collectionIds = [...new Set(data.collectionIds ?? [])];
+      // 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.
+      const hasCollectionEntries =
+        data.collectionEntries !== undefined &&
+        data.collectionEntries.length > 0;
+      const collectionInsertRows: {
+        siteId: string;
+        postId: string;
+        collectionId: string;
+        createdAt: number;
+        position: number;
+        pinnedAt: number | null;
+      }[] = hasCollectionEntries
+        ? (() => {
+            const seen = new Set<string>();
+            const rows: {
+              siteId: string;
+              postId: string;
+              collectionId: string;
+              createdAt: number;
+              position: number;
+              pinnedAt: number | null;
+            }[] = [];
+            let fallbackPosition = 0;
+            for (const entry of data.collectionEntries ?? []) {
+              if (seen.has(entry.collectionId)) continue;
+              seen.add(entry.collectionId);
+              rows.push({
+                siteId,
+                postId: id,
+                collectionId: entry.collectionId,
+                createdAt: entry.createdAt ?? timestamp,
+                position: entry.position ?? fallbackPosition,
+                pinnedAt: entry.pinnedAt ?? null,
+              });
+              fallbackPosition++;
+            }
+            return rows;
+          })()
+        : [...new Set(data.collectionIds ?? [])].map((collectionId, index) => ({
+            siteId,
+            postId: id,
+            collectionId,
+            createdAt: timestamp,
+            position: index,
+            pinnedAt: null,
+          }));
 
       try {
         if (usesBatchWrites) {
@@ -1282,14 +1700,14 @@ export function createPostService(
               format,
               status,
               visibility,
-              pinnedAt: data.pinned ? timestamp : null,
-              featuredAt: data.featured ? timestamp : null,
-              title: data.title ?? null,
-              url: data.url ?? null,
-              body: body ?? null,
+              pinnedAt: resolvedPinnedAt,
+              featuredAt: resolvedFeaturedAt,
+              title,
+              url,
+              body,
               bodyHtml,
               bodyText,
-              quoteText: data.quoteText ?? null,
+              quoteText,
               summary,
               rating,
               replyToId: data.replyToId ?? null,
@@ -1333,16 +1751,9 @@ export function createPostService(
             );
           }
 
-          if (collectionIds.length > 0) {
+          if (collectionInsertRows.length > 0) {
             writeQueries.push(
-              db.insert(postCollections).values(
-                collectionIds.map((collectionId) => ({
-                  siteId,
-                  postId: id,
-                  collectionId,
-                  createdAt: timestamp,
-                })),
-              ),
+              db.insert(postCollections).values(collectionInsertRows),
             );
           }
 
@@ -1360,14 +1771,14 @@ export function createPostService(
               format,
               status,
               visibility,
-              pinnedAt: data.pinned ? timestamp : null,
-              featuredAt: data.featured ? timestamp : null,
-              title: data.title ?? null,
-              url: data.url ?? null,
-              body: body ?? null,
+              pinnedAt: resolvedPinnedAt,
+              featuredAt: resolvedFeaturedAt,
+              title,
+              url,
+              body,
               bodyHtml,
               bodyText,
-              quoteText: data.quoteText ?? null,
+              quoteText,
               summary,
               rating,
               replyToId: data.replyToId ?? null,
@@ -1406,15 +1817,8 @@ export function createPostService(
               });
             }
 
-            if (collectionIds.length > 0) {
-              await tx.insert(postCollections).values(
-                collectionIds.map((collectionId) => ({
-                  siteId,
-                  postId: id,
-                  collectionId,
-                  createdAt: timestamp,
-                })),
-              );
+            if (collectionInsertRows.length > 0) {
+              await tx.insert(postCollections).values(collectionInsertRows);
             }
           });
         }
@@ -1434,7 +1838,7 @@ export function createPostService(
       }
 
       // Bump thread root's lastActivityAt when creating a published reply
-      if (data.replyToId && status === "published") {
+      if (data.replyToId && status === "published" && !data.quietReply) {
         await recalculateThreadLastActivity(threadId);
       }
 
@@ -1447,13 +1851,25 @@ export function createPostService(
         await createAttachmentMediaIds(attachmentInputs, deps);
 
       try {
-        const post = await this.create(data, summaryConfig);
+        const post = await this.create(
+          { ...data, attachments: attachmentInputs },
+          summaryConfig,
+        );
 
         try {
           if (orderedMediaIds.length > 0) {
             await deps.media.attachToPost(post.id, orderedMediaIds);
           }
           await applyAttachmentAltUpdates(attachmentInputs, deps);
+
+          // Best-effort: fetch and store link preview thumbnail
+          await resolveAndStorePreview(
+            post.id,
+            post.format,
+            post.url,
+            deps.storage,
+          );
+
           return post;
         } catch (error) {
           await deps.media.attachToPost(post.id, []).catch(() => undefined);
@@ -1470,6 +1886,47 @@ export function createPostService(
       }
     },
 
+    async createThreadWithAttachments(items, deps, summaryConfig) {
+      if (items.length < 2) {
+        throw new ValidationError("A thread requires at least 2 posts.");
+      }
+
+      const created: Post[] = [];
+
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (!item) continue;
+        const { data, attachments } = item;
+        const prevPost = created[i - 1];
+        const postData: CreatePost = {
+          ...data,
+          // Chain each post as a reply to the previous one (server-side chaining)
+          replyToId: i === 0 ? data.replyToId : prevPost?.id,
+        };
+
+        try {
+          const post = await this.createWithAttachments(
+            postData,
+            attachments,
+            deps,
+            summaryConfig,
+          );
+          created.push(post);
+        } catch (error) {
+          // Rollback: delete all already-created posts in reverse order
+          for (const p of [...created].reverse()) {
+            await this.delete(p.id, {
+              media: deps.media,
+              storage: deps.storage,
+            }).catch(() => undefined);
+          }
+          throw error;
+        }
+      }
+
+      return created;
+    },
+
     async update(id, data, summaryConfig) {
       const existing = await this.getById(id);
       if (!existing) return null;
@@ -1479,9 +1936,12 @@ export function createPostService(
         data.format !== undefined
           ? ensurePostFormat(data.format)
           : existing.format;
-      const nextUrl = data.url !== undefined ? data.url : existing.url;
+      const nextUrl =
+        data.url !== undefined ? data.url?.trim() || null : existing.url;
       const nextQuoteText =
-        data.quoteText !== undefined ? data.quoteText : existing.quoteText;
+        data.quoteText !== undefined
+          ? data.quoteText?.trim() || null
+          : existing.quoteText;
       const nextStatus =
         data.status !== undefined
           ? ensurePostStatus(data.status)
@@ -1493,11 +1953,26 @@ export function createPostService(
       const nextRating =
         data.rating !== undefined ? ensurePostRating(data.rating) : undefined;
 
+      const nextTitle =
+        data.title !== undefined ? data.title?.trim() || null : existing.title;
+
       assertPostFormatShape({
         format: nextFormat,
-        title: data.title !== undefined ? data.title : existing.title,
+        title: nextTitle,
+        body:
+          data.body !== undefined || data.bodyMarkdown !== undefined
+            ? data.bodyMarkdown
+              ? markdownToTiptapJson(data.bodyMarkdown)
+              : (data.body ?? null)
+            : existing.body,
         url: nextUrl,
         quoteText: nextQuoteText,
+        // During update we can't cheaply resolve final attachment state;
+        // existing posts already passed creation validation, so we only
+        // guard against clearing all text fields here.
+        hasAttachments: data.attachments
+          ? data.attachments.length > 0
+          : undefined,
       });
       assertDraftPublishedAt(nextStatus, data.publishedAt);
 
@@ -1520,32 +1995,40 @@ export function createPostService(
       }
 
       if (data.format !== undefined) updates.format = nextFormat;
-      if (data.title !== undefined) updates.title = data.title;
-      if (data.url !== undefined) updates.url = data.url;
-      if (data.quoteText !== undefined) updates.quoteText = data.quoteText;
+      if (data.title !== undefined) updates.title = nextTitle;
+      if (data.url !== undefined) updates.url = nextUrl;
+      if (data.quoteText !== undefined) updates.quoteText = nextQuoteText;
       if (data.rating !== undefined) updates.rating = nextRating;
-      if (data.pinned !== undefined)
-        updates.pinnedAt = data.pinned ? now() : null;
-      if (data.featured !== undefined)
-        updates.featuredAt = data.featured ? now() : null;
+      // Prefer explicit timestamp when provided; fall back to boolean shorthand.
+      if (data.pinnedAt !== undefined) {
+        updates.pinnedAt = data.pinnedAt;
+      } else if (data.pinned !== undefined) {
+        updates.pinnedAt = data.pinned ? timestamp : null;
+      }
+      if (data.featuredAt !== undefined) {
+        updates.featuredAt = data.featuredAt;
+      } else if (data.featured !== undefined) {
+        updates.featuredAt = data.featured ? timestamp : null;
+      }
 
       if (data.body !== undefined || data.bodyMarkdown !== undefined) {
-        const normalizedBody = data.bodyMarkdown
+        const rawBody = data.bodyMarkdown
           ? markdownToTiptapJson(data.bodyMarkdown)
           : (data.body ?? null);
+        const normalizedBody = rawBody ? trimTiptapBody(rawBody) : null;
         updates.body = normalizedBody;
         updates.bodyHtml = normalizedBody
           ? renderTiptapJson(normalizedBody)
           : null;
         updates.bodyText = normalizedBody
-          ? extractBodyText(normalizedBody)
+          ? extractBodyText(normalizedBody, { includeLinkHrefs: true })
           : null;
       }
 
       // Recompute summary when body, title, or format change
       if (summaryConfig) {
         const format = nextFormat;
-        const title = data.title !== undefined ? data.title : existing.title;
+        const title = nextTitle;
         const body =
           data.bodyMarkdown !== undefined
             ? data.bodyMarkdown
@@ -1572,7 +2055,10 @@ export function createPostService(
             "Cannot change visibility of a thread reply. Update the root post instead.",
           );
         }
-        if (data.pinned !== undefined) {
+        if (
+          (data.pinnedAt !== undefined && data.pinnedAt !== null) ||
+          data.pinned === true
+        ) {
           throw new ConflictError(
             "Cannot pin a thread reply. Pin the root post instead.",
           );
@@ -1631,9 +2117,9 @@ export function createPostService(
       }
 
       // Complex case: cascade + update + collection sync atomically
-      const existingCollectionIds = needsCollectionSync
-        ? await getCollectionIdsForPost(id)
-        : [];
+      const existingCollectionTimestamps = needsCollectionSync
+        ? await getPostCollectionTimestamps(id)
+        : new Map<string, number>();
       let updateResult: (typeof posts.$inferSelect)[] | undefined;
 
       if (usesBatchWrites) {
@@ -1688,38 +2174,30 @@ export function createPostService(
         );
 
         if (needsCollectionSync) {
-          const existingIds = new Set(existingCollectionIds);
-          const nextIds = new Set(nextCollectionIds);
-          const removedIds = existingCollectionIds.filter(
-            (cid) => !nextIds.has(cid),
-          );
-          const addedIds = nextCollectionIds.filter(
-            (cid) => !existingIds.has(cid),
-          );
-
-          if (removedIds.length > 0) {
-            writeQueries.push(
-              db
-                .delete(postCollections)
-                .where(
-                  and(
-                    eq(postCollections.siteId, siteId),
-                    eq(postCollections.postId, id),
-                    inArray(postCollections.collectionId, removedIds),
-                  ),
+          // Delete all and re-insert to preserve user-specified ordering
+          writeQueries.push(
+            db
+              .delete(postCollections)
+              .where(
+                and(
+                  eq(postCollections.siteId, siteId),
+                  eq(postCollections.postId, id),
                 ),
-            );
-          }
+              ),
+          );
 
-          if (addedIds.length > 0) {
+          if (nextCollectionIds.length > 0) {
             const collectionTimestamp = now();
             writeQueries.push(
               db.insert(postCollections).values(
-                addedIds.map((collectionId) => ({
+                nextCollectionIds.map((collectionId, index) => ({
                   siteId,
                   postId: id,
                   collectionId,
-                  createdAt: collectionTimestamp,
+                  createdAt:
+                    existingCollectionTimestamps.get(collectionId) ??
+                    collectionTimestamp,
+                  position: index,
                 })),
               ),
             );
@@ -1779,35 +2257,27 @@ export function createPostService(
             .returning();
 
           if (needsCollectionSync) {
-            const existingIds = new Set(existingCollectionIds);
-            const nextIds = new Set(nextCollectionIds);
-            const removedIds = existingCollectionIds.filter(
-              (cid) => !nextIds.has(cid),
-            );
-            const addedIds = nextCollectionIds.filter(
-              (cid) => !existingIds.has(cid),
-            );
-
-            if (removedIds.length > 0) {
-              await tx
-                .delete(postCollections)
-                .where(
-                  and(
-                    eq(postCollections.siteId, siteId),
-                    eq(postCollections.postId, id),
-                    inArray(postCollections.collectionId, removedIds),
-                  ),
-                );
-            }
+            // Delete all and re-insert to preserve user-specified ordering
+            await tx
+              .delete(postCollections)
+              .where(
+                and(
+                  eq(postCollections.siteId, siteId),
+                  eq(postCollections.postId, id),
+                ),
+              );
 
-            if (addedIds.length > 0) {
+            if (nextCollectionIds.length > 0) {
               const collectionTimestamp = now();
               await tx.insert(postCollections).values(
-                addedIds.map((collectionId) => ({
+                nextCollectionIds.map((collectionId, index) => ({
                   siteId,
                   postId: id,
                   collectionId,
-                  createdAt: collectionTimestamp,
+                  createdAt:
+                    existingCollectionTimestamps.get(collectionId) ??
+                    collectionTimestamp,
+                  position: index,
                 })),
               );
             }
@@ -1824,7 +2294,32 @@ export function createPostService(
 
     async updateWithAttachments(id, data, attachments, deps, summaryConfig) {
       if (attachments === undefined) {
-        return this.update(id, data, summaryConfig);
+        const existing = await this.getById(id);
+        const post = await this.update(id, data, summaryConfig);
+        if (post && existing) {
+          const urlChanged =
+            data.url !== undefined && data.url !== existing.url;
+          const formatChanged =
+            data.format !== undefined && data.format !== existing.format;
+          if (urlChanged || formatChanged) {
+            await deletePreviewImage(existing.previewImageKey, deps.storage);
+            await db
+              .update(posts)
+              .set({
+                previewImageKey: null,
+                previewKind: null,
+                previewProvider: null,
+              })
+              .where(and(eq(posts.siteId, siteId), eq(posts.id, post.id)));
+            await resolveAndStorePreview(
+              post.id,
+              post.format,
+              post.url,
+              deps.storage,
+            );
+          }
+        }
+        return post;
       }
 
       const existingPost = await this.getById(id);
@@ -1862,17 +2357,41 @@ export function createPostService(
         await applyAttachmentAltUpdates(attachments, deps);
 
         const nextAttachmentIds = new Set(orderedMediaIds);
-        const removedTextAttachmentIds = existingAttachments
-          .filter(
-            (attachment) =>
-              attachment.mimeType === "text/x-tiptap+json" &&
-              !nextAttachmentIds.has(attachment.id),
-          )
+        const removedAttachmentIds = existingAttachments
+          .filter((attachment) => !nextAttachmentIds.has(attachment.id))
           .map((attachment) => attachment.id);
         await deps.media
-          .deleteByIds(removedTextAttachmentIds, deps.storage)
+          .deleteByIds(removedAttachmentIds, deps.storage)
           .catch(() => undefined);
 
+        // Best-effort: update link preview when URL changes
+        const urlChanged =
+          data.url !== undefined && data.url !== existingPost.url;
+        const formatChanged =
+          data.format !== undefined && data.format !== existingPost.format;
+        if (urlChanged || formatChanged) {
+          // Clean up old preview image
+          await deletePreviewImage(existingPost.previewImageKey, deps.storage);
+
+          // Clear preview fields first (may be re-set by resolveAndStorePreview)
+          await db
+            .update(posts)
+            .set({
+              previewImageKey: null,
+              previewKind: null,
+              previewProvider: null,
+            })
+            .where(and(eq(posts.siteId, siteId), eq(posts.id, post.id)));
+
+          // Fetch new preview if applicable
+          await resolveAndStorePreview(
+            post.id,
+            post.format,
+            post.url,
+            deps.storage,
+          );
+        }
+
         return post;
       } catch (error) {
         if (replacedAttachments) {
@@ -1900,17 +2419,16 @@ export function createPostService(
       const existing = await this.getById(id);
       if (!existing) return false;
 
-      // Clean up media for all affected posts
-      if (deps?.media) {
-        let postIds: string[];
-        if (!isThreadReply(existing)) {
-          const thread = await this.getThread(id);
-          postIds = thread.map((p) => p.id);
-        } else {
-          postIds = [id];
-        }
+      const isRoot = !isThreadReply(existing);
+      const affectedPosts: Post[] = isRoot
+        ? await this.getThread(id)
+        : [existing];
 
-        const mediaMap = await deps.media.getByPostIds(postIds);
+      // Clean up media and preview images
+      if (deps?.media) {
+        const mediaMap = await deps.media.getByPostIds(
+          affectedPosts.map((p) => p.id),
+        );
         const allMedia = [...mediaMap.values()].flat();
         if (allMedia.length > 0) {
           await deps.media.deleteByIds(
@@ -1918,18 +2436,20 @@ export function createPostService(
             deps.storage,
           );
         }
+
+        for (const p of affectedPosts) {
+          await deletePreviewImage(p.previewImageKey, deps.storage);
+        }
       }
 
       const timestamp = now();
 
-      // If this is a thread root, soft delete all posts in the thread
-      if (!isThreadReply(existing)) {
+      if (isRoot) {
         await db
           .update(posts)
           .set({ deletedAt: timestamp, updatedAt: timestamp })
           .where(and(eq(posts.siteId, siteId), eq(posts.threadId, id)));
       } else {
-        // Soft-delete the single reply
         await db
           .update(posts)
           .set({ deletedAt: timestamp, updatedAt: timestamp })
@@ -1940,6 +2460,23 @@ export function createPostService(
       return true;
     },
 
+    async deleteThreadDraft(id, deps) {
+      const deleted = await this.delete(id, deps);
+      if (!deleted) return false;
+
+      // Release path_registry entries for all posts in the thread so slugs
+      // can be reused by the replacement thread.
+      const threadRows = await db
+        .select({ id: posts.id })
+        .from(posts)
+        .where(and(eq(posts.siteId, siteId), eq(posts.threadId, id)));
+      for (const row of threadRows) {
+        await resolvedPaths.deleteByPostId(row.id);
+      }
+
+      return true;
+    },
+
     async getThread(rootId) {
       const rows = await db
         .select()
@@ -2029,7 +2566,7 @@ export function createPostService(
       const rows = await db
         .select({
           threadId: posts.threadId,
-          count: sql<number>`count(*)`.as("count"),
+          count: sql<number>`CAST(count(*) AS INTEGER)`.as("count"),
         })
         .from(posts)
         .where(
@@ -2058,10 +2595,10 @@ export function createPostService(
           id: posts.id,
           threadId: posts.threadId,
           createdAt: posts.createdAt,
-          previewRank: sql<number>`ROW_NUMBER() OVER (
+          previewRank: sql<number>`CAST(ROW_NUMBER() OVER (
             PARTITION BY ${posts.threadId}
             ORDER BY ${posts.createdAt}, ${posts.id}
-          )`.as("preview_rank"),
+          ) AS INTEGER)`.as("preview_rank"),
         })
         .from(posts)
         .where(
@@ -2115,14 +2652,17 @@ export function createPostService(
         .select({
           id: posts.id,
           threadId: posts.threadId,
-          replyToId: posts.replyToId,
-          replyRank: sql<number>`ROW_NUMBER() OVER (
+          firstReplyRank: sql<number>`CAST(ROW_NUMBER() OVER (
+            PARTITION BY ${posts.threadId}
+            ORDER BY ${posts.createdAt}, ${posts.id}
+          ) AS INTEGER)`.as("first_reply_rank"),
+          latestReplyRank: sql<number>`CAST(ROW_NUMBER() OVER (
             PARTITION BY ${posts.threadId}
             ORDER BY ${posts.createdAt} DESC, ${posts.id} DESC
-          )`.as("reply_rank"),
-          totalReplyCount: sql<number>`COUNT(*) OVER (
+          ) AS INTEGER)`.as("latest_reply_rank"),
+          totalReplyCount: sql<number>`CAST(COUNT(*) OVER (
             PARTITION BY ${posts.threadId}
-          )`.as("total_reply_count"),
+          ) AS INTEGER)`.as("total_reply_count"),
         })
         .from(posts)
         .where(
@@ -2136,41 +2676,72 @@ export function createPostService(
         )
         .as("ranked_replies");
 
-      const latestReplyRows = await db
+      const contextRows = await db
         .select({
           threadId: rankedReplies.threadId,
-          latestReplyId: rankedReplies.id,
-          latestReplyToId: rankedReplies.replyToId,
+          id: rankedReplies.id,
+          firstReplyRank: rankedReplies.firstReplyRank,
+          latestReplyRank: rankedReplies.latestReplyRank,
           totalReplyCount: rankedReplies.totalReplyCount,
         })
         .from(rankedReplies)
-        .where(eq(rankedReplies.replyRank, 1));
+        .where(
+          or(
+            eq(rankedReplies.firstReplyRank, 1),
+            lte(rankedReplies.latestReplyRank, 2),
+          ),
+        );
 
-      const relatedPostIds = latestReplyRows.flatMap((row) => {
-        const ids = [row.latestReplyId];
+      const hydratedPosts = await hydratePostsById(
+        contextRows.map((row) => row.id),
+      );
 
-        if (row.latestReplyToId && row.latestReplyToId !== row.threadId) {
-          ids.push(row.latestReplyToId);
+      const contextByThreadId = new Map<
+        string,
+        {
+          secondReplyId: string | null;
+          penultimateReplyId: string | null;
+          latestReplyId: string | null;
+          totalReplyCount: number;
         }
+      >();
+      for (const row of contextRows) {
+        const existing = contextByThreadId.get(row.threadId) ?? {
+          secondReplyId: null,
+          penultimateReplyId: null,
+          latestReplyId: null,
+          totalReplyCount: row.totalReplyCount,
+        };
 
-        return ids;
-      });
-      const hydratedPosts = await hydratePostsById(relatedPostIds);
+        if (row.firstReplyRank === 1) {
+          existing.secondReplyId = row.id;
+        }
+        if (row.latestReplyRank === 2) {
+          existing.penultimateReplyId = row.id;
+        }
+        if (row.latestReplyRank === 1) {
+          existing.latestReplyId = row.id;
+        }
+
+        contextByThreadId.set(row.threadId, existing);
+      }
 
       const result = new Map<string, ThreadTimelineContext>();
-      for (const row of latestReplyRows) {
-        const latestReply = hydratedPosts.get(row.latestReplyId);
-        if (!latestReply) continue;
+      for (const [threadId, context] of contextByThreadId) {
+        if (!context.latestReplyId) continue;
 
-        const parentReply =
-          row.latestReplyToId && row.latestReplyToId !== row.threadId
-            ? (hydratedPosts.get(row.latestReplyToId) ?? null)
-            : null;
+        const latestReply = hydratedPosts.get(context.latestReplyId);
+        if (!latestReply) continue;
 
-        result.set(row.threadId, {
+        result.set(threadId, {
+          secondReply: context.secondReplyId
+            ? (hydratedPosts.get(context.secondReplyId) ?? null)
+            : null,
+          penultimateReply: context.penultimateReplyId
+            ? (hydratedPosts.get(context.penultimateReplyId) ?? null)
+            : null,
           latestReply,
-          parentReply,
-          totalReplyCount: row.totalReplyCount,
+          totalReplyCount: context.totalReplyCount,
         });
       }
 
@@ -2185,7 +2756,10 @@ export function createPostService(
 
       const rows = await db
         .select({
-          count: sql<number>`count(distinct ${posts.threadId})`.as("count"),
+          count:
+            sql<number>`CAST(count(distinct ${posts.threadId}) AS INTEGER)`.as(
+              "count",
+            ),
         })
         .from(posts)
         .where(and(...conditions));
@@ -2241,7 +2815,10 @@ export function createPostService(
 
       const rows = await db
         .select({
-          count: sql<number>`count(distinct ${posts.threadId})`.as("count"),
+          count:
+            sql<number>`CAST(count(distinct ${posts.threadId}) AS INTEGER)`.as(
+              "count",
+            ),
         })
         .from(posts)
         .innerJoin(
@@ -2272,10 +2849,10 @@ export function createPostService(
         buildCollectionMembershipCondition(collectionIds),
       ];
       const sortOrder = options.sortOrder ?? "newest";
-      const collectedAt =
+      const publishedAt =
         sortOrder === "oldest"
-          ? sql<number>`MIN(${postCollections.createdAt})`.as("collected_at")
-          : sql<number>`MAX(${postCollections.createdAt})`.as("collected_at");
+          ? sql<number>`MIN(${posts.publishedAt})`.as("published_at")
+          : sql<number>`MAX(${posts.publishedAt})`.as("published_at");
       const ratingPresence = sql<number>`MAX(
         CASE
           WHEN ${posts.rating} IS NULL THEN 0
@@ -2286,10 +2863,16 @@ export function createPostService(
         "rating_value",
       );
 
+      const collectionPinnedAt =
+        sql<number>`MAX(coalesce(${postCollections.pinnedAt}, -1))`.as(
+          "collection_pinned_at",
+        );
+
       const baseQuery = db
         .select({
           threadId: posts.threadId,
-          collectedAt,
+          publishedAt,
+          collectionPinnedAt,
           ratingPresence,
           ratingValue,
         })
@@ -2306,15 +2889,24 @@ export function createPostService(
 
       let query =
         sortOrder === "oldest"
-          ? baseQuery.orderBy(asc(collectedAt), asc(posts.threadId))
+          ? baseQuery.orderBy(
+              desc(collectionPinnedAt),
+              asc(publishedAt),
+              asc(posts.threadId),
+            )
           : sortOrder === "rating_desc"
             ? baseQuery.orderBy(
+                desc(collectionPinnedAt),
                 desc(ratingPresence),
                 desc(ratingValue),
-                desc(collectedAt),
+                desc(publishedAt),
                 desc(posts.threadId),
               )
-            : baseQuery.orderBy(desc(collectedAt), desc(posts.threadId));
+            : baseQuery.orderBy(
+                desc(collectionPinnedAt),
+                desc(publishedAt),
+                desc(posts.threadId),
+              );
 
       if (options.limit !== undefined) {
         query = query.limit(options.limit) as typeof query;
@@ -2339,14 +2931,23 @@ export function createPostService(
         ...buildThreadRootPageConditions(options),
         buildCollectionMembershipCondition(collectionIds),
       ];
+      const publishedAt = sql<number>`MAX(${posts.publishedAt})`.as(
+        "published_at",
+      );
       const collectedAt = sql<number>`MAX(${postCollections.createdAt})`.as(
         "collected_at",
       );
+      const collectionPinnedAt =
+        sql<number>`MAX(coalesce(${postCollections.pinnedAt}, -1))`.as(
+          "collection_pinned_at",
+        );
 
       let query = db
         .select({
           threadId: posts.threadId,
+          publishedAt,
           collectedAt,
+          collectionPinnedAt,
         })
         .from(posts)
         .innerJoin(
@@ -2358,7 +2959,11 @@ export function createPostService(
         )
         .where(and(...conditions))
         .groupBy(posts.threadId)
-        .orderBy(desc(collectedAt), desc(posts.threadId));
+        .orderBy(
+          desc(collectionPinnedAt),
+          desc(publishedAt),
+          desc(posts.threadId),
+        );
 
       if (options.limit !== undefined) {
         query = query.limit(options.limit) as typeof query;
@@ -2504,5 +3109,61 @@ export function createPostService(
 
       return rows.map((r) => parseInt(r.year, 10));
     },
+
+    async reindexBodyText(options = {}) {
+      const requested = options.limit ?? 50;
+      const limit = Math.min(Math.max(Math.trunc(requested), 1), 500);
+      const cursor = options.cursor;
+
+      const whereConditions = [
+        eq(posts.siteId, siteId),
+        isNull(posts.deletedAt),
+      ];
+      if (cursor) whereConditions.push(gt(posts.id, cursor));
+
+      // Fetch one extra row to detect end-of-data without a separate COUNT.
+      const rows = await db
+        .select({
+          id: posts.id,
+          body: posts.body,
+          bodyText: posts.bodyText,
+        })
+        .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;
+
+      let updated = 0;
+      let skipped = 0;
+
+      for (const row of batch) {
+        const nextBodyText = row.body
+          ? extractBodyText(row.body, { includeLinkHrefs: true })
+          : null;
+        if (nextBodyText === row.bodyText) {
+          skipped++;
+          continue;
+        }
+        await db
+          .update(posts)
+          .set({ bodyText: nextBodyText })
+          .where(and(eq(posts.siteId, siteId), eq(posts.id, row.id)));
+        updated++;
+      }
+
+      const lastRow = batch.at(-1);
+      const lastId = lastRow ? lastRow.id : null;
+
+      return {
+        processed: batch.length,
+        updated,
+        skipped,
+        nextCursor: hasMore ? lastId : null,
+        done: !hasMore,
+      };
+    },
   };
 }