@jant/core 0.3.39 → 1.0.0

package/src/services/post.ts

@@ -9,6 +9,7 @@
 import {
   eq,
   and,
+  or,
   type SQL,
   type SQLWrapper,
   isNull,
@@ -31,9 +32,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 +66,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 {
@@ -83,6 +91,7 @@ export interface PostFilters {
   pinned?: boolean;
   featured?: boolean;
   collectionId?: string;
+  collectionIds?: string[];
   /** Exclude posts that are replies (have replyToId set) */
   excludeReplies?: boolean;
   /** Exclude posts hidden from Latest from results */
@@ -138,8 +147,18 @@ export interface CollectionFeedEntry {
   collectedAt: number;
 }
 
+export interface PostBodyContent {
+  id: string;
+  type: "post";
+  format: Format;
+  contentFormat: "markdown";
+  content: string;
+  chars: number;
+}
+
 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;
@@ -150,6 +169,8 @@ export interface PostService {
   list(filters?: PostFilters): Promise<Post[]>;
   /** 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) */
+  countUpTo(filters: PostFilters | undefined, limit: number): Promise<number>;
   /** Count posts grouped by published year-month (YYYY-MM) */
   countByYearMonth(
     filters?: PostFilters,
@@ -161,6 +182,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,
@@ -181,6 +220,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,
@@ -207,16 +251,31 @@ export interface PostService {
     collectionId: string,
     options?: ThreadRootPageOptions,
   ): Promise<number>;
+  /** Count distinct thread roots that contain published posts in any of the given collections */
+  countCollectionThreadRootsForCollections(
+    collectionIds: string[],
+    options?: ThreadRootPageOptions,
+  ): Promise<number>;
   /** List collection thread root IDs ordered by collected-at or rating semantics */
   listCollectionThreadRootIds(
     collectionId: string,
     options?: CollectionThreadRootPageOptions,
   ): Promise<string[]>;
+  /** List collection thread root IDs for a union of collections */
+  listCollectionThreadRootIdsForCollections(
+    collectionIds: string[],
+    options?: CollectionThreadRootPageOptions,
+  ): Promise<string[]>;
   /** List collection feed entries ordered by latest added-at timestamp */
   listCollectionFeedEntries(
     collectionId: string,
     options?: ThreadRootPageOptions,
   ): Promise<CollectionFeedEntry[]>;
+  /** List collection feed entries for a union of collections */
+  listCollectionFeedEntriesForCollections(
+    collectionIds: string[],
+    options?: ThreadRootPageOptions,
+  ): 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 */
@@ -224,6 +283,11 @@ export interface PostService {
     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 */
   getDistinctYears(filters?: PostFilters): Promise<number[]>;
   /** For each thread ID, return the ID of the last published, non-deleted post */
@@ -236,24 +300,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;
@@ -326,8 +374,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);
@@ -340,6 +390,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;
   }
 
@@ -470,6 +532,124 @@ export function createPostService(
       .where(and(eq(posts.siteId, siteId), eq(posts.id, rootId)));
   }
 
+  function normalizeCollectionIds(collectionIds: readonly string[]): string[] {
+    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> {
+    const uniqueCollectionIds = normalizeCollectionIds(collectionIds);
+    const firstCollectionId = uniqueCollectionIds[0];
+    if (!firstCollectionId) {
+      return sql`0 = 1`;
+    }
+
+    return uniqueCollectionIds.length === 1
+      ? eq(postCollections.collectionId, firstCollectionId)
+      : inArray(postCollections.collectionId, uniqueCollectionIds);
+  }
+
+  function buildPostCollectionSubqueryCondition(
+    collectionIds: readonly string[],
+  ): SQL<unknown> {
+    const uniqueCollectionIds = normalizeCollectionIds(collectionIds);
+    if (uniqueCollectionIds.length === 0) {
+      return sql`0 = 1`;
+    }
+
+    const placeholders = uniqueCollectionIds.map(
+      (collectionId) => sql`${collectionId}`,
+    );
+    return sql`${posts.id} IN (
+      SELECT post_id
+      FROM post_collection
+      WHERE site_id = ${siteId}
+        AND collection_id IN (${sql.join(placeholders, sql`, `)})
+    )`;
+  }
+
   /** Build WHERE conditions from filters (shared by list and count) */
   function buildFilterConditions(filters: PostFilters) {
     const conditions = [eq(posts.siteId, siteId)];
@@ -503,15 +683,13 @@ export function createPostService(
     if (filters.format) {
       conditions.push(eq(posts.format, filters.format));
     }
-    if (filters.collectionId !== undefined) {
-      // Filter by collection via junction table
+    if (filters.collectionIds !== undefined) {
       conditions.push(
-        sql`${posts.id} IN (
-          SELECT post_id
-          FROM post_collection
-          WHERE site_id = ${siteId}
-            AND collection_id = ${filters.collectionId}
-        )`,
+        buildPostCollectionSubqueryCondition(filters.collectionIds),
+      );
+    } else if (filters.collectionId !== undefined) {
+      conditions.push(
+        buildPostCollectionSubqueryCondition([filters.collectionId]),
       );
     }
     if (filters.threadId) {
@@ -573,6 +751,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);
   }
@@ -732,6 +929,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,
@@ -923,6 +1123,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[],
@@ -960,6 +1178,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) {
@@ -1015,6 +1247,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)
@@ -1024,29 +1264,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),
                 );
 
@@ -1062,13 +1304,29 @@ export function createPostService(
       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);
 
       return result[0]?.count ?? 0;
     },
 
+    async countUpTo(filters = {}, limit) {
+      const normalizedLimit = Math.max(0, Math.trunc(limit));
+      if (normalizedLimit === 0) {
+        return 0;
+      }
+
+      const conditions = buildFilterConditions(filters);
+      const rows = await db
+        .select({ id: posts.id })
+        .from(posts)
+        .where(conditions.length > 0 ? and(...conditions) : undefined)
+        .limit(normalizedLimit);
+
+      return rows.length;
+    },
+
     async countByYearMonth(filters = {}) {
       const conditions = [
         ...buildFilterConditions(filters),
@@ -1079,7 +1337,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)
@@ -1099,22 +1357,31 @@ 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;
 
       // 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,
@@ -1127,18 +1394,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.
@@ -1162,6 +1456,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)) {
@@ -1176,7 +1478,7 @@ export function createPostService(
           const slugified = slugify(normalized);
           slug = await generatePostSlug({
             slug: slugified || undefined,
-            title: data.title,
+            title: titleForSlug,
             idLength: config.slugIdLength,
             isAvailable: isSlugAvailable,
           });
@@ -1189,13 +1491,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) {
@@ -1208,14 +1558,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,
@@ -1259,16 +1609,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),
             );
           }
 
@@ -1286,14 +1629,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,
@@ -1332,15 +1675,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);
             }
           });
         }
@@ -1360,7 +1696,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);
       }
 
@@ -1373,13 +1709,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);
@@ -1396,6 +1744,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;
@@ -1405,9 +1794,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)
@@ -1419,11 +1811,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);
 
@@ -1446,19 +1853,27 @@ 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)
@@ -1471,7 +1886,7 @@ export function createPostService(
       // 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
@@ -1498,7 +1913,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.",
           );
@@ -1557,9 +1975,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) {
@@ -1614,38 +2032,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,
                 })),
               ),
             );
@@ -1705,35 +2115,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,
                 })),
               );
             }
@@ -1750,7 +2152,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);
@@ -1788,17 +2215,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) {
@@ -1826,17 +2277,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(
@@ -1844,18 +2294,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 })
@@ -1866,6 +2318,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()
@@ -1955,7 +2424,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(
@@ -1984,10 +2453,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(
@@ -2041,14 +2510,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(
@@ -2062,41 +2534,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,
         });
       }
 
@@ -2111,7 +2614,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));
@@ -2150,14 +2656,27 @@ export function createPostService(
     },
 
     async countCollectionThreadRoots(collectionId, options = {}) {
+      return this.countCollectionThreadRootsForCollections(
+        [collectionId],
+        options,
+      );
+    },
+
+    async countCollectionThreadRootsForCollections(
+      collectionIds,
+      options = {},
+    ) {
       const conditions = [
         ...buildThreadRootPageConditions(options),
-        eq(postCollections.collectionId, collectionId),
+        buildCollectionMembershipCondition(collectionIds),
       ];
 
       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(
@@ -2173,15 +2692,25 @@ export function createPostService(
     },
 
     async listCollectionThreadRootIds(collectionId, options = {}) {
+      return this.listCollectionThreadRootIdsForCollections(
+        [collectionId],
+        options,
+      );
+    },
+
+    async listCollectionThreadRootIdsForCollections(
+      collectionIds,
+      options = {},
+    ) {
       const conditions = [
         ...buildThreadRootPageConditions(options),
-        eq(postCollections.collectionId, collectionId),
+        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
@@ -2192,10 +2721,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,
         })
@@ -2212,15 +2747,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;
@@ -2234,18 +2778,34 @@ export function createPostService(
     },
 
     async listCollectionFeedEntries(collectionId, options = {}) {
+      return this.listCollectionFeedEntriesForCollections(
+        [collectionId],
+        options,
+      );
+    },
+
+    async listCollectionFeedEntriesForCollections(collectionIds, options = {}) {
       const conditions = [
         ...buildThreadRootPageConditions(options),
-        eq(postCollections.collectionId, collectionId),
+        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(
@@ -2257,7 +2817,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;
@@ -2306,6 +2870,13 @@ export function createPostService(
     },
 
     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;
 
@@ -2327,12 +2898,13 @@ export function createPostService(
           .where(
             and(
               eq(posts.siteId, siteId),
-              eq(postCollections.collectionId, collectionId),
+              buildCollectionMembershipCondition(collectionIds),
               inArray(posts.threadId, chunk),
               eq(posts.status, "published"),
               isNull(posts.deletedAt),
             ),
           )
+          .groupBy(posts.threadId, posts.id)
           .orderBy(posts.threadId, posts.createdAt, posts.id),
       );