@jant/core 0.3.37 → 0.3.39

package/src/services/post.ts

@@ -3,29 +3,58 @@
  *
  * CRUD operations for posts with Thread support.
  * Posts have format (note/link/quote), status (draft/published),
- * visibility (public/unlisted/private), featuredAt, and pinnedAt timestamp.
+ * visibility (public/latest_hidden/private), featuredAt, and pinnedAt timestamp.
  */
 
-import { eq, and, isNull, desc, inArray, sql, isNotNull } from "drizzle-orm";
-import type { BatchItem } from "drizzle-orm/batch";
-import { uuidv7 } from "uuidv7";
-import { type Database, batchQueryRows } from "../db/index.js";
-import { pathRegistry, posts, postCollections } from "../db/schema.js";
+import {
+  eq,
+  and,
+  type SQL,
+  type SQLWrapper,
+  isNull,
+  desc,
+  inArray,
+  sql,
+  isNotNull,
+  asc,
+  lte,
+} from "drizzle-orm";
+import {
+  type Database,
+  batchQueryRows,
+  supportsDrizzleTransaction,
+} from "../db/index.js";
+import type { DatabaseDialect } from "../db/dialect.js";
+import {
+  sqliteSchemaBundle,
+  type DatabaseSchema,
+} 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 { extractSummary, extractBodyText } from "../lib/summary.js";
 import { markdownToTiptapJson } from "../lib/markdown-to-tiptap.js";
 import { generatePostSlug } from "../lib/slug.js";
+import { getSlugValidationIssue } from "../lib/slug-format.js";
 import { normalizePath, slugify } from "../lib/url.js";
 import type { StorageDriver } from "../lib/storage.js";
 import type { MediaService } from "./media.js";
+import {
+  FORMATS,
+  MAX_MEDIA_ATTACHMENTS,
+  STATUSES,
+  VISIBILITIES,
+} from "../types.js";
 import type {
+  CollectionSortOrder,
   Format,
   Status,
   Visibility,
+  SortOrder,
   MediaKind,
   Post,
   CreatePost,
+  PostAttachmentInput,
   UpdatePost,
   ThreadTimelineContext,
 } from "../types.js";
@@ -42,6 +71,11 @@ export interface PostDeleteDeps {
   storage?: StorageDriver | null;
 }
 
+export interface PostAttachmentDeps extends PostDeleteDeps {
+  storageDriver: string;
+  maxFileSizeMB: number;
+}
+
 export interface PostFilters {
   format?: Format;
   status?: Status;
@@ -51,8 +85,8 @@ export interface PostFilters {
   collectionId?: string;
   /** Exclude posts that are replies (have replyToId set) */
   excludeReplies?: boolean;
-  /** Exclude unlisted posts from results */
-  excludeUnlisted?: boolean;
+  /** Exclude posts hidden from Latest from results */
+  excludeLatestHidden?: boolean;
   /** Exclude private posts from results */
   excludePrivate?: boolean;
   includeDeleted?: boolean;
@@ -67,8 +101,12 @@ export interface PostFilters {
   hasMedia?: boolean;
   /** Filter by title presence */
   hasTitle?: boolean;
+  /** Filter by rating presence */
+  hasRating?: boolean;
+  /** Explicit result sort order */
+  sortOrder?: SortOrder;
   limit?: number;
-  cursor?: string; // post id for cursor pagination (UUIDv7 sorts chronologically)
+  cursor?: string;
   offset?: number; // offset for page-based pagination
 }
 
@@ -78,18 +116,63 @@ export interface SummaryConfig {
   maxChars: number;
 }
 
+interface ThreadRootPageOptions {
+  status?: Status;
+  excludePrivate?: boolean;
+  limit?: number;
+  offset?: number;
+}
+
+interface CollectionThreadRootPageOptions extends ThreadRootPageOptions {
+  sortOrder?: CollectionSortOrder;
+}
+
+interface CursorSortKey {
+  direction: "asc" | "desc";
+  expr: SQLWrapper;
+  value: number | string;
+}
+
+export interface CollectionFeedEntry {
+  post: Post;
+  collectedAt: number;
+}
+
 export interface PostService {
   getById(id: string): Promise<Post | null>;
   getBySlug(slug: string): Promise<Post | null>;
+  suggestSlug(input: {
+    title?: string;
+    slug?: string;
+    excludePostId?: string;
+  }): Promise<string>;
+  checkSlugAvailability(slug: string, excludePostId?: string): Promise<boolean>;
   list(filters?: PostFilters): Promise<Post[]>;
   /** Count posts matching filters (ignores cursor, offset, limit) */
   count(filters?: PostFilters): Promise<number>;
+  /** Count posts grouped by published year-month (YYYY-MM) */
+  countByYearMonth(
+    filters?: PostFilters,
+  ): Promise<{ yearMonth: string; count: number }[]>;
   create(data: CreatePost, summaryConfig?: SummaryConfig): Promise<Post>;
+  createWithAttachments(
+    data: CreatePost,
+    attachments: PostAttachmentInput[] | undefined,
+    deps: PostAttachmentDeps,
+    summaryConfig?: SummaryConfig,
+  ): Promise<Post>;
   update(
     id: string,
     data: UpdatePost,
     summaryConfig?: SummaryConfig,
   ): Promise<Post | null>;
+  updateWithAttachments(
+    id: string,
+    data: UpdatePost,
+    attachments: PostAttachmentInput[] | undefined,
+    deps: PostAttachmentDeps,
+    summaryConfig?: SummaryConfig,
+  ): Promise<Post | null>;
   /**
    * Soft-delete a post and clean up its media (storage files + DB records).
    * Thread roots cascade to all replies.
@@ -115,6 +198,32 @@ export interface PostService {
   getThreadTimelineContext(
     rootIds: string[],
   ): Promise<Map<string, ThreadTimelineContext>>;
+  /** Count distinct thread roots that contain featured published posts */
+  countFeaturedThreadRoots(options?: ThreadRootPageOptions): Promise<number>;
+  /** List featured thread root IDs ordered by the latest featured post in each thread */
+  listFeaturedThreadRootIds(options?: ThreadRootPageOptions): Promise<string[]>;
+  /** Count distinct thread roots that contain published posts in the given collection */
+  countCollectionThreadRoots(
+    collectionId: 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 feed entries ordered by latest added-at timestamp */
+  listCollectionFeedEntries(
+    collectionId: 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 */
+  getCollectionPostIdsByThread(
+    collectionId: 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 */
@@ -150,11 +259,77 @@ function hasNonEmptyText(value: string | null | undefined): boolean {
   return typeof value === "string" && value.trim().length > 0;
 }
 
+function ensureAllowedPostValue<T extends string>(
+  value: string,
+  allowed: readonly T[],
+  message: string,
+  ErrorCtor: new (message: string) => Error = ValidationError,
+): T {
+  if ((allowed as readonly string[]).includes(value)) {
+    return value as T;
+  }
+
+  throw new ErrorCtor(message);
+}
+
+function ensurePostFormat(
+  value: string,
+  ErrorCtor: new (message: string) => Error = ValidationError,
+): Format {
+  return ensureAllowedPostValue(
+    value,
+    FORMATS,
+    "Format must be note, link, or quote.",
+    ErrorCtor,
+  );
+}
+
+function ensurePostStatus(
+  value: string,
+  ErrorCtor: new (message: string) => Error = ValidationError,
+): Status {
+  return ensureAllowedPostValue(
+    value,
+    STATUSES,
+    "Status must be draft or published.",
+    ErrorCtor,
+  );
+}
+
+function ensurePostVisibility(
+  value: string,
+  ErrorCtor: new (message: string) => Error = ValidationError,
+): Visibility {
+  return ensureAllowedPostValue(
+    value,
+    VISIBILITIES,
+    "Visibility must be public, hidden from Latest, or private.",
+    ErrorCtor,
+  );
+}
+
+function ensurePostRating(
+  value: number | null | undefined,
+  ErrorCtor: new (message: string) => Error = ValidationError,
+): number | null {
+  if (value === null || value === undefined) {
+    return null;
+  }
+
+  if (Number.isInteger(value) && value >= 1 && value <= 5) {
+    return value;
+  }
+
+  throw new ErrorCtor("Rating must be an integer between 1 and 5.");
+}
+
 function assertPostFormatShape(data: {
   format: Format;
+  title?: string | null;
   url?: string | null;
   quoteText?: string | null;
 }): void {
+  const hasTitle = hasNonEmptyText(data.title);
   const hasUrl = hasNonEmptyText(data.url);
   const hasQuoteText = hasNonEmptyText(data.quoteText);
 
@@ -169,6 +344,9 @@ function assertPostFormatShape(data: {
   }
 
   if (data.format === "link") {
+    if (!hasTitle) {
+      throw new ValidationError("Link posts need a title.");
+    }
     if (!hasUrl) {
       throw new ValidationError("Link posts need a URL.");
     }
@@ -198,24 +376,65 @@ function assertDraftPublishedAt(
 
 export function createPostService(
   db: Database,
-  config: { slugIdLength: number },
-  paths: PathService = createPathService(db),
+  config: {
+    slugIdLength: number;
+    databaseDialect?: DatabaseDialect;
+  },
+  siteId: string,
+  paths: PathService | undefined,
+  databaseSchema: DatabaseSchema = sqliteSchemaBundle,
 ): PostService {
+  const resolvedPaths = paths ?? createPathService(db, siteId, databaseSchema);
+  const { pathRegistry, posts, postCollections } = databaseSchema;
+  const databaseDialect = config.databaseDialect ?? "sqlite";
+  const usesBatchWrites = !supportsDrizzleTransaction(db, databaseDialect);
+
+  function buildPublishedYearMonthExpr(): SQL<string> {
+    return databaseDialect === "pg"
+      ? sql<string>`to_char(timezone('UTC', to_timestamp(${posts.publishedAt})), 'YYYY-MM')`
+      : sql<string>`strftime('%Y-%m', ${posts.publishedAt}, 'unixepoch')`;
+  }
+
+  function buildPublishedYearExpr(): SQL<string> {
+    return databaseDialect === "pg"
+      ? sql<string>`to_char(timezone('UTC', to_timestamp(${posts.publishedAt})), 'YYYY')`
+      : sql<string>`strftime('%Y', ${posts.publishedAt}, 'unixepoch')`;
+  }
+
   const effectiveVisibilityExpr = sql<string>`coalesce(
     ${posts.visibility},
     (SELECT root.visibility FROM post AS root WHERE root.id = ${posts.threadId})
   )`;
 
-  /** Check if a slug is available (not used by posts or custom_urls) */
+  /** Check if a slug is available (not used by posts or path_registry) */
   async function isSlugAvailable(slug: string): Promise<boolean> {
-    return paths.isPathAvailable(slug);
+    return resolvedPaths.isPathAvailable(slug);
+  }
+
+  async function isSlugAvailableForPost(
+    slug: string,
+    excludePostId?: string,
+  ): Promise<boolean> {
+    const resolved = await resolvedPaths.resolve(slug);
+    if (!resolved) return true;
+
+    return Boolean(
+      excludePostId &&
+      resolved.kind === "slug" &&
+      resolved.postId === excludePostId,
+    );
   }
 
   async function pathExists(path: string): Promise<boolean> {
     const rows = await db
       .select({ id: pathRegistry.id })
       .from(pathRegistry)
-      .where(eq(pathRegistry.path, normalizePath(path)))
+      .where(
+        and(
+          eq(pathRegistry.siteId, siteId),
+          eq(pathRegistry.path, normalizePath(path)),
+        ),
+      )
       .limit(1);
     return rows.length > 0;
   }
@@ -228,23 +447,32 @@ export function createPostService(
         ),
       })
       .from(posts)
-      .where(and(eq(posts.threadId, rootId), isNull(posts.deletedAt)));
+      .where(
+        and(
+          eq(posts.siteId, siteId),
+          eq(posts.threadId, rootId),
+          isNull(posts.deletedAt),
+        ),
+      );
 
     const latestPublishedAt = rootRows[0]?.latestPublishedAt ?? null;
     const root = await db
       .select({ updatedAt: posts.updatedAt })
       .from(posts)
-      .where(eq(posts.id, rootId))
+      .where(and(eq(posts.siteId, siteId), eq(posts.id, rootId)))
       .limit(1);
 
     const lastActivityAt = latestPublishedAt ?? root[0]?.updatedAt ?? now();
 
-    await db.update(posts).set({ lastActivityAt }).where(eq(posts.id, rootId));
+    await db
+      .update(posts)
+      .set({ lastActivityAt })
+      .where(and(eq(posts.siteId, siteId), eq(posts.id, rootId)));
   }
 
   /** Build WHERE conditions from filters (shared by list and count) */
   function buildFilterConditions(filters: PostFilters) {
-    const conditions = [];
+    const conditions = [eq(posts.siteId, siteId)];
 
     if (filters.status) {
       conditions.push(eq(posts.status, filters.status));
@@ -252,8 +480,8 @@ export function createPostService(
     if (filters.visibility !== undefined) {
       conditions.push(sql`${effectiveVisibilityExpr} = ${filters.visibility}`);
     }
-    if (filters.excludeUnlisted) {
-      conditions.push(sql`${effectiveVisibilityExpr} != 'unlisted'`);
+    if (filters.excludeLatestHidden) {
+      conditions.push(sql`${effectiveVisibilityExpr} != 'latest_hidden'`);
     }
     if (filters.excludePrivate) {
       conditions.push(sql`${effectiveVisibilityExpr} != 'private'`);
@@ -278,7 +506,12 @@ export function createPostService(
     if (filters.collectionId !== undefined) {
       // Filter by collection via junction table
       conditions.push(
-        sql`${posts.id} IN (SELECT post_id FROM post_collection WHERE collection_id = ${filters.collectionId})`,
+        sql`${posts.id} IN (
+          SELECT post_id
+          FROM post_collection
+          WHERE site_id = ${siteId}
+            AND collection_id = ${filters.collectionId}
+        )`,
       );
     }
     if (filters.threadId) {
@@ -299,14 +532,27 @@ export function createPostService(
     if (filters.mediaKinds && filters.mediaKinds.length > 0) {
       const placeholders = filters.mediaKinds.map((k) => sql`${k}`);
       conditions.push(
-        sql`${posts.id} IN (SELECT post_id FROM media WHERE media_kind IN (${sql.join(placeholders, sql`, `)}))`,
+        sql`${posts.id} IN (
+          SELECT post_id
+          FROM media
+          WHERE site_id = ${siteId}
+            AND media_kind IN (${sql.join(placeholders, sql`, `)})
+        )`,
       );
     }
     if (filters.hasMedia !== undefined) {
       if (filters.hasMedia) {
-        conditions.push(sql`${posts.id} IN (SELECT post_id FROM media)`);
+        conditions.push(
+          sql`${posts.id} IN (
+            SELECT post_id FROM media WHERE site_id = ${siteId}
+          )`,
+        );
       } else {
-        conditions.push(sql`${posts.id} NOT IN (SELECT post_id FROM media)`);
+        conditions.push(
+          sql`${posts.id} NOT IN (
+            SELECT post_id FROM media WHERE site_id = ${siteId}
+          )`,
+        );
       }
     }
     if (filters.hasTitle !== undefined) {
@@ -318,20 +564,163 @@ export function createPostService(
         conditions.push(sql`(${posts.title} IS NULL OR ${posts.title} = '')`);
       }
     }
+    if (filters.hasRating !== undefined) {
+      conditions.push(
+        filters.hasRating ? isNotNull(posts.rating) : isNull(posts.rating),
+      );
+    }
 
     return conditions;
   }
 
+  function getCursorSortTimestamp(row: typeof posts.$inferSelect): number {
+    return row.status === "draft" ? row.updatedAt : (row.lastActivityAt ?? -1);
+  }
+
+  function buildLexicographicCursorCondition(
+    keys: [CursorSortKey, ...CursorSortKey[]],
+  ): SQL<unknown> {
+    const [first, ...rest] = keys;
+    const comparison =
+      first.direction === "desc"
+        ? sql`${first.expr} < ${first.value}`
+        : sql`${first.expr} > ${first.value}`;
+
+    if (rest.length === 0) {
+      return comparison;
+    }
+
+    return sql`(
+      ${comparison}
+      OR (${first.expr} = ${first.value} AND ${buildLexicographicCursorCondition(
+        rest as [CursorSortKey, ...CursorSortKey[]],
+      )})
+    )`;
+  }
+
+  async function buildListCursorCondition(
+    filters: PostFilters,
+  ): Promise<SQL<unknown> | null> {
+    if (!filters.cursor) {
+      return null;
+    }
+
+    const cursorRow = await db
+      .select()
+      .from(posts)
+      .where(and(eq(posts.siteId, siteId), eq(posts.id, filters.cursor)))
+      .limit(1);
+    const cursorPost = cursorRow[0];
+
+    if (!cursorPost) {
+      return null;
+    }
+
+    const sortTimestampExpr =
+      filters.status === "draft"
+        ? posts.updatedAt
+        : filters.status === "published"
+          ? posts.lastActivityAt
+          : sql<number>`CASE
+              WHEN ${posts.status} = 'draft' THEN ${posts.updatedAt}
+              ELSE ${posts.lastActivityAt}
+            END`;
+    const pinnedSortExpr = sql<number>`coalesce(${posts.pinnedAt}, -1)`;
+    const featuredSortExpr = sql<number>`coalesce(${posts.featuredAt}, -1)`;
+    const sortTimestampSortExpr = sql<number>`coalesce(${sortTimestampExpr}, -1)`;
+    const ratingPresenceExpr = sql<number>`CASE
+      WHEN ${posts.rating} IS NULL THEN 0
+      ELSE 1
+    END`;
+    const ratingSortExpr = sql<number>`coalesce(${posts.rating}, -1)`;
+    const cursorPinnedAt = cursorPost.pinnedAt ?? -1;
+    const cursorFeaturedAt = cursorPost.featuredAt ?? -1;
+    const cursorSortTimestamp = getCursorSortTimestamp(cursorPost);
+    const cursorRatingPresence = cursorPost.rating === null ? 0 : 1;
+    const cursorRating = cursorPost.rating ?? -1;
+
+    if (filters.featured || filters.sortOrder === undefined) {
+      if (filters.featured) {
+        return buildLexicographicCursorCondition([
+          { direction: "desc", expr: pinnedSortExpr, value: cursorPinnedAt },
+          {
+            direction: "desc",
+            expr: featuredSortExpr,
+            value: cursorFeaturedAt,
+          },
+          { direction: "desc", expr: posts.id, value: cursorPost.id },
+        ]);
+      }
+
+      return buildLexicographicCursorCondition([
+        { direction: "desc", expr: pinnedSortExpr, value: cursorPinnedAt },
+        {
+          direction: "desc",
+          expr: sortTimestampSortExpr,
+          value: cursorSortTimestamp,
+        },
+        { direction: "desc", expr: posts.id, value: cursorPost.id },
+      ]);
+    }
+
+    if (filters.sortOrder === "oldest") {
+      return buildLexicographicCursorCondition([
+        { direction: "desc", expr: pinnedSortExpr, value: cursorPinnedAt },
+        {
+          direction: "asc",
+          expr: sortTimestampSortExpr,
+          value: cursorSortTimestamp,
+        },
+        { direction: "asc", expr: posts.id, value: cursorPost.id },
+      ]);
+    }
+
+    if (filters.sortOrder === "rating_desc") {
+      return buildLexicographicCursorCondition([
+        { direction: "desc", expr: pinnedSortExpr, value: cursorPinnedAt },
+        {
+          direction: "desc",
+          expr: ratingPresenceExpr,
+          value: cursorRatingPresence,
+        },
+        { direction: "desc", expr: ratingSortExpr, value: cursorRating },
+        {
+          direction: "desc",
+          expr: sortTimestampSortExpr,
+          value: cursorSortTimestamp,
+        },
+        { direction: "desc", expr: posts.id, value: cursorPost.id },
+      ]);
+    }
+
+    return buildLexicographicCursorCondition([
+      { direction: "desc", expr: pinnedSortExpr, value: cursorPinnedAt },
+      {
+        direction: "desc",
+        expr: ratingPresenceExpr,
+        value: cursorRatingPresence,
+      },
+      { direction: "asc", expr: ratingSortExpr, value: cursorRating },
+      {
+        direction: "desc",
+        expr: sortTimestampSortExpr,
+        value: cursorSortTimestamp,
+      },
+      { direction: "desc", expr: posts.id, value: cursorPost.id },
+    ]);
+  }
+
   function toPost(
     row: typeof posts.$inferSelect,
     slug: string,
-    visibility: Visibility,
+    visibility: string,
   ): Post {
     return {
       id: row.id,
-      format: row.format as Format,
-      status: row.status as Status,
-      visibility,
+      siteId: row.siteId,
+      format: ensurePostFormat(row.format, Error),
+      status: ensurePostStatus(row.status, Error),
+      visibility: ensurePostVisibility(visibility, Error),
       pinnedAt: row.pinnedAt,
       featuredAt: row.featuredAt,
       slug,
@@ -342,7 +731,7 @@ export function createPostService(
       bodyText: row.bodyText,
       quoteText: row.quoteText,
       summary: row.summary,
-      rating: row.rating,
+      rating: ensurePostRating(row.rating, Error),
       replyToId: row.replyToId,
       threadId: row.threadId,
       deletedAt: row.deletedAt,
@@ -357,19 +746,21 @@ export function createPostService(
     row: typeof posts.$inferSelect | undefined,
   ): Promise<Post | null> {
     if (!row) return null;
-    const slug = await paths.getPostSlug(row.id);
+    const slug = await resolvedPaths.getPostSlug(row.id);
     if (!slug) return null;
     const rootVisibilityMap = await getThreadVisibilityMap([row.threadId]);
     const visibility = rootVisibilityMap.get(row.threadId) ?? row.visibility;
     if (!visibility) return null;
-    return toPost(row, slug, visibility as Visibility);
+    return toPost(row, slug, visibility);
   }
 
   async function hydratePosts(
     rows: (typeof posts.$inferSelect)[],
   ): Promise<Post[]> {
     if (rows.length === 0) return [];
-    const slugMap = await paths.getPostSlugMap(rows.map((row) => row.id));
+    const slugMap = await resolvedPaths.getPostSlugMap(
+      rows.map((row) => row.id),
+    );
     const rootVisibilityMap = await getThreadVisibilityMap(
       rows.map((row) => row.threadId),
     );
@@ -378,13 +769,40 @@ export function createPostService(
         const slug = slugMap.get(row.id);
         const visibility =
           rootVisibilityMap.get(row.threadId) ?? row.visibility;
-        return slug && visibility
-          ? toPost(row, slug, visibility as Visibility)
-          : null;
+        return slug && visibility ? toPost(row, slug, visibility) : null;
       })
       .filter((row): row is Post => row !== null);
   }
 
+  async function hydratePostsById(ids: string[]): Promise<Map<string, Post>> {
+    const result = new Map<string, Post>();
+    const uniqueIds = [...new Set(ids)];
+
+    if (uniqueIds.length === 0) {
+      return result;
+    }
+
+    const rows = await batchQueryRows(uniqueIds, (chunk) =>
+      db
+        .select()
+        .from(posts)
+        .where(
+          and(
+            eq(posts.siteId, siteId),
+            inArray(posts.id, chunk),
+            eq(posts.status, "published"),
+            isNull(posts.deletedAt),
+          ),
+        ),
+    );
+
+    for (const post of await hydratePosts(rows)) {
+      result.set(post.id, post);
+    }
+
+    return result;
+  }
+
   async function getThreadVisibilityMap(
     threadIds: string[],
   ): Promise<Map<string, Visibility>> {
@@ -396,38 +814,188 @@ export function createPostService(
       db
         .select({ id: posts.id, visibility: posts.visibility })
         .from(posts)
-        .where(inArray(posts.id, chunk)),
+        .where(and(eq(posts.siteId, siteId), inArray(posts.id, chunk))),
     );
 
     for (const row of rows) {
       if (row.visibility) {
-        result.set(row.id, row.visibility as Visibility);
+        result.set(row.id, ensurePostVisibility(row.visibility, Error));
       }
     }
 
     return result;
   }
 
+  function buildThreadRootPageConditions(options?: ThreadRootPageOptions) {
+    const conditions = [isNull(posts.deletedAt)];
+    const status = options?.status;
+
+    if (status) {
+      conditions.push(eq(posts.status, status));
+    }
+    if (options?.excludePrivate) {
+      conditions.push(sql`${effectiveVisibilityExpr} != 'private'`);
+    }
+
+    return conditions;
+  }
+
+  function isMediaAttachmentInput(
+    attachment: PostAttachmentInput,
+  ): attachment is Extract<PostAttachmentInput, { type: "media" }> {
+    return attachment.type === "media";
+  }
+
+  async function createAttachmentMediaIds(
+    attachments: PostAttachmentInput[],
+    deps: PostAttachmentDeps,
+  ) {
+    if (attachments.length > MAX_MEDIA_ATTACHMENTS) {
+      throw new ValidationError(
+        `Posts allow at most ${MAX_MEDIA_ATTACHMENTS} attachments`,
+      );
+    }
+
+    const orderedMediaIds: string[] = [];
+    const createdTextMediaIds: string[] = [];
+    const referencedMediaIds = attachments
+      .filter(isMediaAttachmentInput)
+      .map((attachment) => attachment.mediaId);
+
+    await deps.media.validateIds(referencedMediaIds);
+
+    try {
+      for (const attachment of attachments) {
+        if (isMediaAttachmentInput(attachment)) {
+          orderedMediaIds.push(attachment.mediaId);
+          continue;
+        }
+
+        const created = await deps.media.createTextAttachment(attachment, {
+          storage: deps.storage,
+          storageDriver: deps.storageDriver,
+          maxFileSizeMB: deps.maxFileSizeMB,
+        });
+        orderedMediaIds.push(created.id);
+        createdTextMediaIds.push(created.id);
+      }
+    } catch (error) {
+      await cleanupCreatedTextAttachments(createdTextMediaIds, deps);
+      throw error;
+    }
+
+    return { orderedMediaIds, createdTextMediaIds };
+  }
+
+  async function applyAttachmentAltUpdates(
+    attachments: PostAttachmentInput[],
+    deps: PostAttachmentDeps,
+  ) {
+    const altUpdates = attachments
+      .filter(isMediaAttachmentInput)
+      .filter((attachment) => attachment.alt !== undefined)
+      .map((attachment) =>
+        deps.media.updateAlt(attachment.mediaId, attachment.alt ?? ""),
+      );
+
+    await Promise.all(altUpdates);
+  }
+
+  async function cleanupCreatedTextAttachments(
+    mediaIds: string[],
+    deps: PostAttachmentDeps,
+  ) {
+    if (mediaIds.length === 0) return;
+    await deps.media.deleteByIds(mediaIds, deps.storage).catch(() => undefined);
+  }
+
+  async function getCollectionIdsForPost(postId: string): Promise<string[]> {
+    const rows = await db
+      .select({ collectionId: postCollections.collectionId })
+      .from(postCollections)
+      .where(
+        and(
+          eq(postCollections.siteId, siteId),
+          eq(postCollections.postId, postId),
+        ),
+      );
+
+    return rows.map((row) => row.collectionId);
+  }
+
+  function buildRollbackUpdate(
+    post: Post,
+    collectionIds: string[],
+  ): UpdatePost {
+    return {
+      format: post.format,
+      title: post.title,
+      body: post.body ?? null,
+      slug: post.slug,
+      status: post.status,
+      visibility: post.visibility,
+      pinned: post.pinnedAt !== null,
+      featured: post.featuredAt !== null,
+      url: post.url,
+      quoteText: post.quoteText,
+      rating: post.rating,
+      collectionIds,
+      publishedAt: post.publishedAt ?? undefined,
+    };
+  }
+
   return {
     async getById(id) {
       const result = await db
         .select()
         .from(posts)
-        .where(and(eq(posts.id, id), isNull(posts.deletedAt)))
+        .where(
+          and(
+            eq(posts.siteId, siteId),
+            eq(posts.id, id),
+            isNull(posts.deletedAt),
+          ),
+        )
         .limit(1);
       return hydratePost(result[0]);
     },
 
     async getBySlug(slug) {
-      const resolved = await paths.resolve(slug);
+      const resolved = await resolvedPaths.resolve(slug);
       if (!resolved || resolved.kind !== "slug" || !resolved.postId) {
         return null;
       }
       return this.getById(resolved.postId);
     },
 
+    async suggestSlug(input) {
+      return generatePostSlug({
+        slug: input.slug,
+        title: input.title,
+        idLength: config.slugIdLength,
+        isAvailable: (candidate) =>
+          isSlugAvailableForPost(candidate, input.excludePostId),
+      });
+    },
+
+    async checkSlugAvailability(slug, excludePostId) {
+      const issue = getSlugValidationIssue(slug);
+      if (issue === "invalid") {
+        throw new ValidationError("Slug contains invalid characters");
+      }
+      if (issue === "reserved") {
+        throw new ValidationError("Slug is reserved");
+      }
+
+      return isSlugAvailableForPost(slug, excludePostId);
+    },
+
     async list(filters = {}) {
       const conditions = buildFilterConditions(filters);
+      const cursorCondition = await buildListCursorCondition(filters);
+      if (filters.cursor && !cursorCondition) {
+        return [];
+      }
       const sortTimestamp =
         filters.status === "draft"
           ? posts.updatedAt
@@ -438,21 +1006,50 @@ export function createPostService(
                 ELSE ${posts.lastActivityAt}
               END`;
 
-      if (filters.cursor) {
-        conditions.push(sql`${posts.id} < ${filters.cursor}`);
+      if (cursorCondition) {
+        conditions.push(cursorCondition);
       }
 
-      let query = db
+      const ratingPresence = sql<number>`CASE
+          WHEN ${posts.rating} IS NULL THEN 0
+          ELSE 1
+        END`;
+
+      const baseQuery = db
         .select()
         .from(posts)
         .where(conditions.length > 0 ? and(...conditions) : undefined)
-        .orderBy(
-          desc(posts.pinnedAt),
-          filters.featured ? desc(posts.featuredAt) : desc(sortTimestamp),
-          desc(posts.id),
-        )
         .limit(filters.limit ?? 100);
 
+      let query =
+        filters.featured || filters.sortOrder === undefined
+          ? baseQuery.orderBy(
+              desc(posts.pinnedAt),
+              filters.featured ? desc(posts.featuredAt) : desc(sortTimestamp),
+              desc(posts.id),
+            )
+          : filters.sortOrder === "oldest"
+            ? baseQuery.orderBy(
+                desc(posts.pinnedAt),
+                asc(sortTimestamp),
+                asc(posts.id),
+              )
+            : filters.sortOrder === "rating_desc"
+              ? baseQuery.orderBy(
+                  desc(posts.pinnedAt),
+                  desc(ratingPresence),
+                  desc(posts.rating),
+                  desc(sortTimestamp),
+                  desc(posts.id),
+                )
+              : baseQuery.orderBy(
+                  desc(posts.pinnedAt),
+                  desc(ratingPresence),
+                  asc(posts.rating),
+                  desc(sortTimestamp),
+                  desc(posts.id),
+                );
+
       if (filters.offset !== undefined) {
         query = query.offset(filters.offset) as typeof query;
       }
@@ -472,12 +1069,39 @@ export function createPostService(
       return result[0]?.count ?? 0;
     },
 
+    async countByYearMonth(filters = {}) {
+      const conditions = [
+        ...buildFilterConditions(filters),
+        isNotNull(posts.publishedAt),
+      ];
+      const publishedYearMonthExpr = buildPublishedYearMonthExpr();
+
+      return db
+        .select({
+          yearMonth: publishedYearMonthExpr.as("year_month"),
+          count: sql<number>`count(*)`.as("count"),
+        })
+        .from(posts)
+        .where(conditions.length > 0 ? and(...conditions) : undefined)
+        .groupBy(publishedYearMonthExpr)
+        .orderBy(desc(publishedYearMonthExpr));
+    },
+
     async create(data, summaryConfig) {
-      const id = uuidv7();
+      const id = createEntityId("post");
       const timestamp = now();
+      const format = ensurePostFormat(data.format);
+      const requestedStatus =
+        data.status !== undefined ? ensurePostStatus(data.status) : undefined;
+      const requestedVisibility =
+        data.visibility !== undefined
+          ? ensurePostVisibility(data.visibility)
+          : undefined;
+      const rating = ensurePostRating(data.rating);
 
       assertPostFormatShape({
-        format: data.format,
+        format,
+        title: data.title,
         url: data.url,
         quoteText: data.quoteText,
       });
@@ -490,7 +1114,7 @@ export function createPostService(
 
       // Generate summary for titled notes with body content
       let summary: string | null = null;
-      if (data.format === "note" && data.title && body && summaryConfig) {
+      if (format === "note" && data.title && body && summaryConfig) {
         summary = extractSummary(
           body,
           summaryConfig.maxParagraphs,
@@ -500,8 +1124,8 @@ export function createPostService(
 
       // Handle thread relationship
       let threadId = id;
-      let status: Status = data.status ?? "published";
-      let visibility: Visibility | null = data.visibility ?? "public";
+      let status: Status = requestedStatus ?? "published";
+      let visibility: Visibility | null = requestedVisibility ?? "public";
 
       if (data.replyToId) {
         const parent = await this.getById(data.replyToId);
@@ -524,7 +1148,7 @@ export function createPostService(
             : await this.getById(parent.threadId);
         if (root) {
           if (data.status !== "draft") {
-            status = root.status as Status;
+            status = root.status;
           }
         }
         visibility = null;
@@ -557,7 +1181,7 @@ export function createPostService(
             isAvailable: isSlugAvailable,
           });
           // Verify the alias path is available before proceeding
-          if (!(await paths.isPathAvailable(normalized))) {
+          if (!(await resolvedPaths.isPathAvailable(normalized))) {
             throw new ConflictError(`Path "${normalized}" is already in use`);
           }
           aliasPath = normalized;
@@ -574,48 +1198,41 @@ export function createPostService(
       const collectionIds = [...new Set(data.collectionIds ?? [])];
 
       try {
-        const writeQueries: BatchItem<"sqlite">[] = [
-          db.insert(posts).values({
-            id,
-            format: data.format,
-            status,
-            visibility,
-            pinnedAt: data.pinned ? timestamp : null,
-            featuredAt: data.featured ? timestamp : null,
-            title: data.title ?? null,
-            url: data.url ?? null,
-            body: body ?? null,
-            bodyHtml,
-            bodyText,
-            quoteText: data.quoteText ?? null,
-            summary,
-            rating: data.rating ?? null,
-            replyToId: data.replyToId ?? null,
-            threadId,
-            publishedAt,
-            lastActivityAt: publishedAt ?? timestamp,
-            createdAt: timestamp,
-            updatedAt: timestamp,
-          }),
-          db.insert(pathRegistry).values({
-            id: uuidv7(),
-            path: normalizePath(slug),
-            kind: "slug",
-            postId: id,
-            collectionId: null,
-            redirectToPath: null,
-            redirectType: null,
-            createdAt: timestamp,
-            updatedAt: timestamp,
-          }),
-        ];
-
-        if (aliasPath) {
+        if (usesBatchWrites) {
+          const writeQueries = [];
+
+          writeQueries.push(
+            db.insert(posts).values({
+              id,
+              siteId,
+              format,
+              status,
+              visibility,
+              pinnedAt: data.pinned ? timestamp : null,
+              featuredAt: data.featured ? timestamp : null,
+              title: data.title ?? null,
+              url: data.url ?? null,
+              body: body ?? null,
+              bodyHtml,
+              bodyText,
+              quoteText: data.quoteText ?? null,
+              summary,
+              rating,
+              replyToId: data.replyToId ?? null,
+              threadId,
+              publishedAt,
+              lastActivityAt: publishedAt ?? timestamp,
+              createdAt: timestamp,
+              updatedAt: timestamp,
+            }),
+          );
+
           writeQueries.push(
             db.insert(pathRegistry).values({
-              id: uuidv7(),
-              path: normalizePath(aliasPath),
-              kind: "alias",
+              id: createEntityId("path"),
+              siteId,
+              path: normalizePath(slug),
+              kind: "slug",
               postId: id,
               collectionId: null,
               redirectToPath: null,
@@ -624,26 +1241,109 @@ export function createPostService(
               updatedAt: timestamp,
             }),
           );
-        }
 
-        if (collectionIds.length > 0) {
-          writeQueries.push(
-            db.insert(postCollections).values(
-              collectionIds.map((collectionId) => ({
+          if (aliasPath) {
+            writeQueries.push(
+              db.insert(pathRegistry).values({
+                id: createEntityId("path"),
+                siteId,
+                path: normalizePath(aliasPath),
+                kind: "alias",
                 postId: id,
-                collectionId,
+                collectionId: null,
+                redirectToPath: null,
+                redirectType: null,
                 createdAt: timestamp,
-              })),
-            ),
+                updatedAt: timestamp,
+              }),
+            );
+          }
+
+          if (collectionIds.length > 0) {
+            writeQueries.push(
+              db.insert(postCollections).values(
+                collectionIds.map((collectionId) => ({
+                  siteId,
+                  postId: id,
+                  collectionId,
+                  createdAt: timestamp,
+                })),
+              ),
+            );
+          }
+
+          await db.batch(
+            writeQueries as [
+              (typeof writeQueries)[number],
+              ...(typeof writeQueries)[number][],
+            ],
           );
-        }
+        } else {
+          await db.transaction(async (tx) => {
+            await tx.insert(posts).values({
+              id,
+              siteId,
+              format,
+              status,
+              visibility,
+              pinnedAt: data.pinned ? timestamp : null,
+              featuredAt: data.featured ? timestamp : null,
+              title: data.title ?? null,
+              url: data.url ?? null,
+              body: body ?? null,
+              bodyHtml,
+              bodyText,
+              quoteText: data.quoteText ?? null,
+              summary,
+              rating,
+              replyToId: data.replyToId ?? null,
+              threadId,
+              publishedAt,
+              lastActivityAt: publishedAt ?? timestamp,
+              createdAt: timestamp,
+              updatedAt: timestamp,
+            });
 
-        await db.batch(
-          writeQueries as [
-            (typeof writeQueries)[number],
-            ...(typeof writeQueries)[number][],
-          ],
-        );
+            await tx.insert(pathRegistry).values({
+              id: createEntityId("path"),
+              siteId,
+              path: normalizePath(slug),
+              kind: "slug",
+              postId: id,
+              collectionId: null,
+              redirectToPath: null,
+              redirectType: null,
+              createdAt: timestamp,
+              updatedAt: timestamp,
+            });
+
+            if (aliasPath) {
+              await tx.insert(pathRegistry).values({
+                id: createEntityId("path"),
+                siteId,
+                path: normalizePath(aliasPath),
+                kind: "alias",
+                postId: id,
+                collectionId: null,
+                redirectToPath: null,
+                redirectType: null,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+              });
+            }
+
+            if (collectionIds.length > 0) {
+              await tx.insert(postCollections).values(
+                collectionIds.map((collectionId) => ({
+                  siteId,
+                  postId: id,
+                  collectionId,
+                  createdAt: timestamp,
+                })),
+              );
+            }
+          });
+        }
       } catch (err) {
         if (err instanceof ConflictError) {
           throw new ConflictError(`Slug "${slug}" is already in use`);
@@ -667,19 +1367,61 @@ export function createPostService(
       return post;
     },
 
+    async createWithAttachments(data, attachments, deps, summaryConfig) {
+      const attachmentInputs = attachments ?? [];
+      const { orderedMediaIds, createdTextMediaIds } =
+        await createAttachmentMediaIds(attachmentInputs, deps);
+
+      try {
+        const post = await this.create(data, summaryConfig);
+
+        try {
+          if (orderedMediaIds.length > 0) {
+            await deps.media.attachToPost(post.id, orderedMediaIds);
+          }
+          await applyAttachmentAltUpdates(attachmentInputs, deps);
+          return post;
+        } catch (error) {
+          await deps.media.attachToPost(post.id, []).catch(() => undefined);
+          await this.delete(post.id, {
+            media: deps.media,
+            storage: deps.storage,
+          }).catch(() => undefined);
+          await cleanupCreatedTextAttachments(createdTextMediaIds, deps);
+          throw error;
+        }
+      } catch (error) {
+        await cleanupCreatedTextAttachments(createdTextMediaIds, deps);
+        throw error;
+      }
+    },
+
     async update(id, data, summaryConfig) {
       const existing = await this.getById(id);
       if (!existing) return null;
 
       const timestamp = now();
-      const nextFormat = data.format ?? existing.format;
+      const nextFormat =
+        data.format !== undefined
+          ? ensurePostFormat(data.format)
+          : existing.format;
       const nextUrl = data.url !== undefined ? data.url : existing.url;
       const nextQuoteText =
         data.quoteText !== undefined ? data.quoteText : existing.quoteText;
-      const nextStatus = data.status ?? existing.status;
+      const nextStatus =
+        data.status !== undefined
+          ? ensurePostStatus(data.status)
+          : existing.status;
+      const nextVisibility =
+        data.visibility !== undefined
+          ? ensurePostVisibility(data.visibility)
+          : undefined;
+      const nextRating =
+        data.rating !== undefined ? ensurePostRating(data.rating) : undefined;
 
       assertPostFormatShape({
         format: nextFormat,
+        title: data.title !== undefined ? data.title : existing.title,
         url: nextUrl,
         quoteText: nextQuoteText,
       });
@@ -694,7 +1436,7 @@ export function createPostService(
         data.slug !== undefined && data.slug !== existing.slug;
       if (slugChanged && data.slug) {
         try {
-          await paths.updatePostSlug(id, data.slug);
+          await resolvedPaths.updatePostSlug(id, data.slug);
         } catch (err) {
           if (err instanceof ConflictError) {
             throw new ConflictError(`Slug "${data.slug}" is already in use`);
@@ -703,11 +1445,11 @@ export function createPostService(
         }
       }
 
-      if (data.format !== undefined) updates.format = data.format;
+      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.rating !== undefined) updates.rating = data.rating;
+      if (data.rating !== undefined) updates.rating = nextRating;
       if (data.pinned !== undefined)
         updates.pinnedAt = data.pinned ? now() : null;
       if (data.featured !== undefined)
@@ -728,7 +1470,7 @@ export function createPostService(
 
       // Recompute summary when body, title, or format change
       if (summaryConfig) {
-        const format = data.format ?? (existing.format as Format);
+        const format = nextFormat;
         const title = data.title !== undefined ? data.title : existing.title;
         const body =
           data.bodyMarkdown !== undefined
@@ -767,8 +1509,7 @@ export function createPostService(
       const statusChanged =
         data.status !== undefined && data.status !== existing.status;
       const visibilityChanged =
-        data.visibility !== undefined &&
-        data.visibility !== existing.visibility;
+        nextVisibility !== undefined && nextVisibility !== existing.visibility;
       const publishedAtChanged = data.publishedAt !== undefined;
       const nextPublishedAt =
         nextStatus === "draft"
@@ -779,9 +1520,9 @@ export function createPostService(
               ? timestamp
               : (existing.publishedAt ?? timestamp);
 
-      if (statusChanged) updates.status = data.status;
+      if (statusChanged) updates.status = nextStatus;
       if (visibilityChanged && !isThreadReply(existing)) {
-        updates.visibility = data.visibility;
+        updates.visibility = nextVisibility;
       }
       if (statusChanged || publishedAtChanged || existing.status === "draft") {
         updates.publishedAt = nextPublishedAt;
@@ -793,6 +1534,9 @@ export function createPostService(
       const needsReplyVisibilityCleanup =
         !isThreadReply(existing) && (statusChanged || visibilityChanged);
       const needsCollectionSync = data.collectionIds !== undefined;
+      const nextCollectionIds = needsCollectionSync
+        ? [...new Set(data.collectionIds ?? [])]
+        : [];
       const needsThreadActivityRecalc =
         statusChanged || publishedAtChanged || existing.status === "draft";
       const hasExtraWrites =
@@ -803,7 +1547,7 @@ export function createPostService(
         const result = await db
           .update(posts)
           .set(updates)
-          .where(eq(posts.id, id))
+          .where(and(eq(posts.siteId, siteId), eq(posts.id, id)))
           .returning();
         if (needsThreadActivityRecalc) {
           await recalculateThreadLastActivity(existing.threadId);
@@ -812,69 +1556,191 @@ export function createPostService(
         return hydratePost(result[0]);
       }
 
-      // Complex case: batch cascade + update + collection sync atomically
-      const writeQueries: BatchItem<"sqlite">[] = [];
+      // Complex case: cascade + update + collection sync atomically
+      const existingCollectionIds = needsCollectionSync
+        ? await getCollectionIdsForPost(id)
+        : [];
+      let updateResult: (typeof posts.$inferSelect)[] | undefined;
 
-      if (needsCascade) {
-        writeQueries.push(
-          db
-            .update(posts)
-            .set({
-              status: data.status ?? (existing.status as Status),
-              publishedAt: nextStatus === "published" ? nextPublishedAt : null,
-              lastActivityAt:
-                nextStatus === "published"
-                  ? (nextPublishedAt ?? timestamp)
-                  : timestamp,
-              updatedAt: timestamp,
-            })
-            .where(and(eq(posts.threadId, id), isNotNull(posts.replyToId))),
-        );
-      }
+      if (usesBatchWrites) {
+        const writeQueries = [];
+
+        if (needsCascade) {
+          writeQueries.push(
+            db
+              .update(posts)
+              .set({
+                status: nextStatus,
+                publishedAt:
+                  nextStatus === "published" ? nextPublishedAt : null,
+                lastActivityAt:
+                  nextStatus === "published"
+                    ? (nextPublishedAt ?? timestamp)
+                    : timestamp,
+                updatedAt: timestamp,
+              })
+              .where(
+                and(
+                  eq(posts.siteId, siteId),
+                  eq(posts.threadId, id),
+                  isNotNull(posts.replyToId),
+                ),
+              ),
+          );
+        }
 
-      if (needsReplyVisibilityCleanup) {
+        if (needsReplyVisibilityCleanup) {
+          writeQueries.push(
+            db
+              .update(posts)
+              .set({ visibility: null, updatedAt: timestamp })
+              .where(
+                and(
+                  eq(posts.siteId, siteId),
+                  eq(posts.threadId, id),
+                  isNotNull(posts.replyToId),
+                ),
+              ),
+          );
+        }
+
+        const updateIdx = writeQueries.length;
         writeQueries.push(
           db
             .update(posts)
-            .set({ visibility: null, updatedAt: timestamp })
-            .where(and(eq(posts.threadId, id), isNotNull(posts.replyToId))),
+            .set(updates)
+            .where(and(eq(posts.siteId, siteId), eq(posts.id, id)))
+            .returning(),
         );
-      }
-
-      // Post update is always present; track its index for result extraction
-      const updateIdx = writeQueries.length;
-      writeQueries.push(
-        db.update(posts).set(updates).where(eq(posts.id, id)).returning(),
-      );
 
-      if (needsCollectionSync) {
-        writeQueries.push(
-          db.delete(postCollections).where(eq(postCollections.postId, id)),
-        );
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guarded by needsCollectionSync
-        if (data.collectionIds!.length > 0) {
-          writeQueries.push(
-            db.insert(postCollections).values(
-              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guarded by needsCollectionSync
-              data.collectionIds!.map((collectionId) => ({
-                postId: id,
-                collectionId,
-                createdAt: now(),
-              })),
-            ),
+        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),
+                  ),
+                ),
+            );
+          }
+
+          if (addedIds.length > 0) {
+            const collectionTimestamp = now();
+            writeQueries.push(
+              db.insert(postCollections).values(
+                addedIds.map((collectionId) => ({
+                  siteId,
+                  postId: id,
+                  collectionId,
+                  createdAt: collectionTimestamp,
+                })),
+              ),
+            );
+          }
         }
+
+        const results = await db.batch(
+          writeQueries as [
+            (typeof writeQueries)[number],
+            ...(typeof writeQueries)[number][],
+          ],
+        );
+        updateResult = results[updateIdx] as
+          | (typeof posts.$inferSelect)[]
+          | undefined;
+      } else {
+        await db.transaction(async (tx) => {
+          if (needsCascade) {
+            await tx
+              .update(posts)
+              .set({
+                status: nextStatus,
+                publishedAt:
+                  nextStatus === "published" ? nextPublishedAt : null,
+                lastActivityAt:
+                  nextStatus === "published"
+                    ? (nextPublishedAt ?? timestamp)
+                    : timestamp,
+                updatedAt: timestamp,
+              })
+              .where(
+                and(
+                  eq(posts.siteId, siteId),
+                  eq(posts.threadId, id),
+                  isNotNull(posts.replyToId),
+                ),
+              );
+          }
+
+          if (needsReplyVisibilityCleanup) {
+            await tx
+              .update(posts)
+              .set({ visibility: null, updatedAt: timestamp })
+              .where(
+                and(
+                  eq(posts.siteId, siteId),
+                  eq(posts.threadId, id),
+                  isNotNull(posts.replyToId),
+                ),
+              );
+          }
+
+          updateResult = await tx
+            .update(posts)
+            .set(updates)
+            .where(and(eq(posts.siteId, siteId), eq(posts.id, id)))
+            .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),
+                  ),
+                );
+            }
+
+            if (addedIds.length > 0) {
+              const collectionTimestamp = now();
+              await tx.insert(postCollections).values(
+                addedIds.map((collectionId) => ({
+                  siteId,
+                  postId: id,
+                  collectionId,
+                  createdAt: collectionTimestamp,
+                })),
+              );
+            }
+          }
+        });
       }
 
-      const results = await db.batch(
-        writeQueries as [
-          (typeof writeQueries)[number],
-          ...(typeof writeQueries)[number][],
-        ],
-      );
-      const updateResult = results[updateIdx] as
-        | (typeof posts.$inferSelect)[]
-        | undefined;
       if (needsThreadActivityRecalc) {
         await recalculateThreadLastActivity(existing.threadId);
         return this.getById(id);
@@ -882,6 +1748,80 @@ export function createPostService(
       return hydratePost(updateResult?.[0]);
     },
 
+    async updateWithAttachments(id, data, attachments, deps, summaryConfig) {
+      if (attachments === undefined) {
+        return this.update(id, data, summaryConfig);
+      }
+
+      const existingPost = await this.getById(id);
+      if (!existingPost) return null;
+
+      const existingCollectionIds = await getCollectionIdsForPost(id);
+      const rollbackData = buildRollbackUpdate(
+        existingPost,
+        existingCollectionIds,
+      );
+      const existingAttachments = await deps.media.getByPostId(id);
+      const previousMediaIds = existingAttachments.map(
+        (attachment) => attachment.id,
+      );
+      const previousAltMap = new Map(
+        existingAttachments.map((attachment) => [
+          attachment.id,
+          attachment.alt ?? "",
+        ]),
+      );
+      const { orderedMediaIds, createdTextMediaIds } =
+        await createAttachmentMediaIds(attachments, deps);
+      const post = await this.update(id, data, summaryConfig);
+
+      if (!post) {
+        await cleanupCreatedTextAttachments(createdTextMediaIds, deps);
+        return null;
+      }
+
+      let replacedAttachments = false;
+
+      try {
+        await deps.media.attachToPost(post.id, orderedMediaIds);
+        replacedAttachments = true;
+        await applyAttachmentAltUpdates(attachments, deps);
+
+        const nextAttachmentIds = new Set(orderedMediaIds);
+        const removedTextAttachmentIds = existingAttachments
+          .filter(
+            (attachment) =>
+              attachment.mimeType === "text/x-tiptap+json" &&
+              !nextAttachmentIds.has(attachment.id),
+          )
+          .map((attachment) => attachment.id);
+        await deps.media
+          .deleteByIds(removedTextAttachmentIds, deps.storage)
+          .catch(() => undefined);
+
+        return post;
+      } catch (error) {
+        if (replacedAttachments) {
+          await deps.media
+            .attachToPost(post.id, previousMediaIds)
+            .catch(() => undefined);
+          await Promise.all(
+            existingAttachments.map((attachment) =>
+              deps.media.updateAlt(
+                attachment.id,
+                previousAltMap.get(attachment.id) ?? "",
+              ),
+            ),
+          ).catch(() => undefined);
+        }
+        await this.update(id, rollbackData, summaryConfig).catch(
+          () => undefined,
+        );
+        await cleanupCreatedTextAttachments(createdTextMediaIds, deps);
+        throw error;
+      }
+    },
+
     async delete(id, deps) {
       const existing = await this.getById(id);
       if (!existing) return false;
@@ -913,13 +1853,13 @@ export function createPostService(
         await db
           .update(posts)
           .set({ deletedAt: timestamp, updatedAt: timestamp })
-          .where(eq(posts.threadId, id));
+          .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 })
-          .where(eq(posts.id, id));
+          .where(and(eq(posts.siteId, siteId), eq(posts.id, id)));
         await recalculateThreadLastActivity(existing.threadId);
       }
 
@@ -930,36 +1870,82 @@ export function createPostService(
       const rows = await db
         .select()
         .from(posts)
-        .where(and(eq(posts.threadId, rootId), isNull(posts.deletedAt)))
+        .where(
+          and(
+            eq(posts.siteId, siteId),
+            eq(posts.threadId, rootId),
+            isNull(posts.deletedAt),
+          ),
+        )
         .orderBy(posts.createdAt);
 
       return hydratePosts(rows);
     },
 
     async updateThreadStatusAndVisibility(rootId, status, visibility) {
+      const nextStatus = ensurePostStatus(status);
+      const nextVisibility = ensurePostVisibility(visibility);
       const timestamp = now();
-      await db.batch([
-        db
-          .update(posts)
-          .set({
-            status,
-            visibility,
-            publishedAt: status === "published" ? timestamp : null,
-            lastActivityAt: timestamp,
-            updatedAt: timestamp,
-          })
-          .where(eq(posts.id, rootId)),
-        db
-          .update(posts)
-          .set({
-            status,
-            visibility: null,
-            publishedAt: status === "published" ? timestamp : null,
-            lastActivityAt: timestamp,
-            updatedAt: timestamp,
-          })
-          .where(and(eq(posts.threadId, rootId), isNotNull(posts.replyToId))),
-      ]);
+      if (usesBatchWrites) {
+        await db.batch([
+          db
+            .update(posts)
+            .set({
+              status: nextStatus,
+              visibility: nextVisibility,
+              publishedAt: nextStatus === "published" ? timestamp : null,
+              lastActivityAt: timestamp,
+              updatedAt: timestamp,
+            })
+            .where(and(eq(posts.siteId, siteId), eq(posts.id, rootId))),
+          db
+            .update(posts)
+            .set({
+              status: nextStatus,
+              visibility: null,
+              publishedAt: nextStatus === "published" ? timestamp : null,
+              lastActivityAt: timestamp,
+              updatedAt: timestamp,
+            })
+            .where(
+              and(
+                eq(posts.siteId, siteId),
+                eq(posts.threadId, rootId),
+                isNotNull(posts.replyToId),
+              ),
+            ),
+        ]);
+      } else {
+        await db.transaction(async (tx) => {
+          await tx
+            .update(posts)
+            .set({
+              status: nextStatus,
+              visibility: nextVisibility,
+              publishedAt: nextStatus === "published" ? timestamp : null,
+              lastActivityAt: timestamp,
+              updatedAt: timestamp,
+            })
+            .where(and(eq(posts.siteId, siteId), eq(posts.id, rootId)));
+
+          await tx
+            .update(posts)
+            .set({
+              status: nextStatus,
+              visibility: null,
+              publishedAt: nextStatus === "published" ? timestamp : null,
+              lastActivityAt: timestamp,
+              updatedAt: timestamp,
+            })
+            .where(
+              and(
+                eq(posts.siteId, siteId),
+                eq(posts.threadId, rootId),
+                isNotNull(posts.replyToId),
+              ),
+            );
+        });
+      }
       await recalculateThreadLastActivity(rootId);
     },
 
@@ -974,6 +1960,7 @@ export function createPostService(
         .from(posts)
         .where(
           and(
+            eq(posts.siteId, siteId),
             inArray(posts.threadId, postIds),
             eq(posts.status, "published"),
             isNotNull(posts.replyToId),
@@ -992,29 +1979,57 @@ export function createPostService(
     async getThreadPreviews(rootIds, previewCount = 3) {
       if (rootIds.length === 0) return new Map();
 
-      const rows = await db
-        .select()
+      const rankedReplies = db
+        .select({
+          id: posts.id,
+          threadId: posts.threadId,
+          createdAt: posts.createdAt,
+          previewRank: sql<number>`ROW_NUMBER() OVER (
+            PARTITION BY ${posts.threadId}
+            ORDER BY ${posts.createdAt}, ${posts.id}
+          )`.as("preview_rank"),
+        })
         .from(posts)
         .where(
           and(
+            eq(posts.siteId, siteId),
             inArray(posts.threadId, rootIds),
             eq(posts.status, "published"),
             isNotNull(posts.replyToId),
             isNull(posts.deletedAt),
           ),
         )
-        .orderBy(posts.threadId, posts.createdAt);
+        .as("ranked_replies");
 
+      const rankedRows = await db
+        .select({
+          id: rankedReplies.id,
+          threadId: rankedReplies.threadId,
+          createdAt: rankedReplies.createdAt,
+        })
+        .from(rankedReplies)
+        .where(lte(rankedReplies.previewRank, previewCount))
+        .orderBy(
+          rankedReplies.threadId,
+          rankedReplies.createdAt,
+          rankedReplies.id,
+        );
+
+      const hydratedPosts = await hydratePostsById(
+        rankedRows.map((row) => row.id),
+      );
       const result = new Map<string, Post[]>();
-      for (const post of await hydratePosts(rows)) {
-        const list = result.get(post.threadId);
+      for (const row of rankedRows) {
+        const post = hydratedPosts.get(row.id);
+        if (!post) continue;
+
+        const list = result.get(row.threadId);
         if (list) {
-          if (list.length < previewCount) {
-            list.push(post);
-          }
-        } else {
-          result.set(post.threadId, [post]);
+          list.push(post);
+          continue;
         }
+
+        result.set(row.threadId, [post]);
       }
       return result;
     },
@@ -1022,46 +2037,312 @@ export function createPostService(
     async getThreadTimelineContext(rootIds) {
       if (rootIds.length === 0) return new Map();
 
-      // Fetch all non-deleted replies ordered by thread, newest first
-      const rows = await db
-        .select()
+      const rankedReplies = db
+        .select({
+          id: posts.id,
+          threadId: posts.threadId,
+          replyToId: posts.replyToId,
+          replyRank: sql<number>`ROW_NUMBER() OVER (
+            PARTITION BY ${posts.threadId}
+            ORDER BY ${posts.createdAt} DESC, ${posts.id} DESC
+          )`.as("reply_rank"),
+          totalReplyCount: sql<number>`COUNT(*) OVER (
+            PARTITION BY ${posts.threadId}
+          )`.as("total_reply_count"),
+        })
         .from(posts)
         .where(
           and(
+            eq(posts.siteId, siteId),
             inArray(posts.threadId, rootIds),
             eq(posts.status, "published"),
             isNotNull(posts.replyToId),
             isNull(posts.deletedAt),
           ),
         )
-        .orderBy(posts.threadId, desc(posts.createdAt), desc(posts.id));
+        .as("ranked_replies");
+
+      const latestReplyRows = await db
+        .select({
+          threadId: rankedReplies.threadId,
+          latestReplyId: rankedReplies.id,
+          latestReplyToId: rankedReplies.replyToId,
+          totalReplyCount: rankedReplies.totalReplyCount,
+        })
+        .from(rankedReplies)
+        .where(eq(rankedReplies.replyRank, 1));
+
+      const relatedPostIds = latestReplyRows.flatMap((row) => {
+        const ids = [row.latestReplyId];
+
+        if (row.latestReplyToId && row.latestReplyToId !== row.threadId) {
+          ids.push(row.latestReplyToId);
+        }
+
+        return ids;
+      });
+      const hydratedPosts = await hydratePostsById(relatedPostIds);
+
+      const result = new Map<string, ThreadTimelineContext>();
+      for (const row of latestReplyRows) {
+        const latestReply = hydratedPosts.get(row.latestReplyId);
+        if (!latestReply) continue;
+
+        const parentReply =
+          row.latestReplyToId && row.latestReplyToId !== row.threadId
+            ? (hydratedPosts.get(row.latestReplyToId) ?? null)
+            : null;
+
+        result.set(row.threadId, {
+          latestReply,
+          parentReply,
+          totalReplyCount: row.totalReplyCount,
+        });
+      }
+
+      return result;
+    },
+
+    async countFeaturedThreadRoots(options = {}) {
+      const conditions = [
+        ...buildThreadRootPageConditions(options),
+        isNotNull(posts.featuredAt),
+      ];
+
+      const rows = await db
+        .select({
+          count: sql<number>`count(distinct ${posts.threadId})`.as("count"),
+        })
+        .from(posts)
+        .where(and(...conditions));
+
+      return rows[0]?.count ?? 0;
+    },
+
+    async listFeaturedThreadRootIds(options = {}) {
+      const conditions = [
+        ...buildThreadRootPageConditions(options),
+        isNotNull(posts.featuredAt),
+      ];
+      const latestFeaturedAt = sql<number>`MAX(${posts.featuredAt})`.as(
+        "latest_featured_at",
+      );
+
+      let query = db
+        .select({
+          threadId: posts.threadId,
+          latestFeaturedAt,
+        })
+        .from(posts)
+        .where(and(...conditions))
+        .groupBy(posts.threadId)
+        .orderBy(desc(latestFeaturedAt), desc(posts.threadId));
+
+      if (options.limit !== undefined) {
+        query = query.limit(options.limit) as typeof query;
+      }
+      if (options.offset !== undefined) {
+        query = query.offset(options.offset) as typeof query;
+      }
+
+      const rows = await query;
+      return rows.map((row) => row.threadId);
+    },
+
+    async countCollectionThreadRoots(collectionId, options = {}) {
+      const conditions = [
+        ...buildThreadRootPageConditions(options),
+        eq(postCollections.collectionId, collectionId),
+      ];
+
+      const rows = await db
+        .select({
+          count: sql<number>`count(distinct ${posts.threadId})`.as("count"),
+        })
+        .from(posts)
+        .innerJoin(
+          postCollections,
+          and(
+            eq(postCollections.siteId, siteId),
+            eq(postCollections.postId, posts.id),
+          ),
+        )
+        .where(and(...conditions));
+
+      return rows[0]?.count ?? 0;
+    },
+
+    async listCollectionThreadRootIds(collectionId, options = {}) {
+      const conditions = [
+        ...buildThreadRootPageConditions(options),
+        eq(postCollections.collectionId, collectionId),
+      ];
+      const sortOrder = options.sortOrder ?? "newest";
+      const collectedAt =
+        sortOrder === "oldest"
+          ? sql<number>`MIN(${postCollections.createdAt})`.as("collected_at")
+          : sql<number>`MAX(${postCollections.createdAt})`.as("collected_at");
+      const ratingPresence = sql<number>`MAX(
+        CASE
+          WHEN ${posts.rating} IS NULL THEN 0
+          ELSE 1
+        END
+      )`.as("rating_presence");
+      const ratingValue = sql<number | null>`MAX(${posts.rating})`.as(
+        "rating_value",
+      );
+
+      const baseQuery = db
+        .select({
+          threadId: posts.threadId,
+          collectedAt,
+          ratingPresence,
+          ratingValue,
+        })
+        .from(posts)
+        .innerJoin(
+          postCollections,
+          and(
+            eq(postCollections.siteId, siteId),
+            eq(postCollections.postId, posts.id),
+          ),
+        )
+        .where(and(...conditions))
+        .groupBy(posts.threadId);
+
+      let query =
+        sortOrder === "oldest"
+          ? baseQuery.orderBy(asc(collectedAt), asc(posts.threadId))
+          : sortOrder === "rating_desc"
+            ? baseQuery.orderBy(
+                desc(ratingPresence),
+                desc(ratingValue),
+                desc(collectedAt),
+                desc(posts.threadId),
+              )
+            : baseQuery.orderBy(desc(collectedAt), desc(posts.threadId));
+
+      if (options.limit !== undefined) {
+        query = query.limit(options.limit) as typeof query;
+      }
+      if (options.offset !== undefined) {
+        query = query.offset(options.offset) as typeof query;
+      }
+
+      const rows = await query;
+      return rows.map((row) => row.threadId);
+    },
+
+    async listCollectionFeedEntries(collectionId, options = {}) {
+      const conditions = [
+        ...buildThreadRootPageConditions(options),
+        eq(postCollections.collectionId, collectionId),
+      ];
+      const collectedAt = sql<number>`MAX(${postCollections.createdAt})`.as(
+        "collected_at",
+      );
+
+      let query = db
+        .select({
+          threadId: posts.threadId,
+          collectedAt,
+        })
+        .from(posts)
+        .innerJoin(
+          postCollections,
+          and(
+            eq(postCollections.siteId, siteId),
+            eq(postCollections.postId, posts.id),
+          ),
+        )
+        .where(and(...conditions))
+        .groupBy(posts.threadId)
+        .orderBy(desc(collectedAt), desc(posts.threadId));
+
+      if (options.limit !== undefined) {
+        query = query.limit(options.limit) as typeof query;
+      }
+      if (options.offset !== undefined) {
+        query = query.offset(options.offset) as typeof query;
+      }
+
+      const rows = await query;
+      const postsById = await hydratePostsById(rows.map((row) => row.threadId));
+
+      return rows.flatMap((row) => {
+        const post = postsById.get(row.threadId);
+        return post ? [{ post, collectedAt: row.collectedAt }] : [];
+      });
+    },
+
+    async getPublishedThreads(rootIds) {
+      const result = new Map<string, Post[]>();
+      if (rootIds.length === 0) return result;
+
+      const unique = [...new Set(rootIds)];
+      const rows = await db
+        .select()
+        .from(posts)
+        .where(
+          and(
+            eq(posts.siteId, siteId),
+            inArray(posts.threadId, unique),
+            eq(posts.status, "published"),
+            isNull(posts.deletedAt),
+          ),
+        )
+        .orderBy(posts.threadId, posts.createdAt, posts.id);
 
-      // Group by threadId, extract latest reply + its parent + count
-      const grouped = new Map<string, Post[]>();
       for (const post of await hydratePosts(rows)) {
-        const list = grouped.get(post.threadId);
-        if (list) {
-          list.push(post);
+        const thread = result.get(post.threadId);
+        if (thread) {
+          thread.push(post);
         } else {
-          grouped.set(post.threadId, [post]);
+          result.set(post.threadId, [post]);
         }
       }
 
-      const result = new Map<string, ThreadTimelineContext>();
-      for (const [threadId, replies] of grouped) {
-        // replies are ordered newest-first; first element is the latest
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- grouped only contains non-empty arrays
-        const latestReply = replies[0]!;
-        const totalReplyCount = replies.length;
-
-        // Find parent of latestReply if it's not the root
-        let parentReply: Post | null = null;
-        if (latestReply.replyToId && latestReply.replyToId !== threadId) {
-          parentReply =
-            replies.find((r) => r.id === latestReply.replyToId) ?? null;
-        }
+      return result;
+    },
 
-        result.set(threadId, { latestReply, parentReply, totalReplyCount });
+    async getCollectionPostIdsByThread(collectionId, threadIds) {
+      const result = new Map<string, string[]>();
+      if (threadIds.length === 0) return result;
+
+      const unique = [...new Set(threadIds)];
+      const rows = await batchQueryRows(unique, (chunk) =>
+        db
+          .select({
+            threadId: posts.threadId,
+            postId: posts.id,
+          })
+          .from(posts)
+          .innerJoin(
+            postCollections,
+            and(
+              eq(postCollections.siteId, siteId),
+              eq(postCollections.postId, posts.id),
+            ),
+          )
+          .where(
+            and(
+              eq(posts.siteId, siteId),
+              eq(postCollections.collectionId, collectionId),
+              inArray(posts.threadId, chunk),
+              eq(posts.status, "published"),
+              isNull(posts.deletedAt),
+            ),
+          )
+          .orderBy(posts.threadId, posts.createdAt, posts.id),
+      );
+
+      for (const row of rows) {
+        const list = result.get(row.threadId);
+        if (list) {
+          list.push(row.postId);
+        } else {
+          result.set(row.threadId, [row.postId]);
+        }
       }
 
       return result;
@@ -1075,20 +2356,23 @@ export function createPostService(
       const rows = await db
         .select({
           threadId: posts.threadId,
-          id: sql<string>`(
-            SELECT p2.id FROM post AS p2
-            WHERE p2.thread_id = ${posts.threadId}
-              AND p2.deleted_at IS NULL
-              AND p2.status = 'published'
-            ORDER BY p2.created_at DESC, p2.id DESC
-            LIMIT 1
-          )`.as("last_id"),
+          id: posts.id,
         })
         .from(posts)
-        .where(inArray(posts.id, unique));
+        .where(
+          and(
+            eq(posts.siteId, siteId),
+            inArray(posts.threadId, unique),
+            eq(posts.status, "published"),
+            isNull(posts.deletedAt),
+          ),
+        )
+        .orderBy(posts.threadId, desc(posts.createdAt), desc(posts.id));
 
       for (const row of rows) {
-        if (row.id) result.set(row.threadId, row.id);
+        if (!result.has(row.threadId)) {
+          result.set(row.threadId, row.id);
+        }
       }
       return result;
     },
@@ -1098,17 +2382,16 @@ export function createPostService(
         ...buildFilterConditions(filters),
         isNotNull(posts.publishedAt),
       ];
+      const publishedYearExpr = buildPublishedYearExpr();
 
       const rows = await db
         .select({
-          year: sql<string>`strftime('%Y', ${posts.publishedAt}, 'unixepoch')`.as(
-            "year",
-          ),
+          year: publishedYearExpr.as("year"),
         })
         .from(posts)
         .where(conditions.length > 0 ? and(...conditions) : undefined)
-        .groupBy(sql`strftime('%Y', ${posts.publishedAt}, 'unixepoch')`)
-        .orderBy(desc(sql`strftime('%Y', ${posts.publishedAt}, 'unixepoch')`));
+        .groupBy(publishedYearExpr)
+        .orderBy(desc(publishedYearExpr));
 
       return rows.map((r) => parseInt(r.year, 10));
     },