@jant/core 0.3.35 → 0.3.37

package/src/services/post.ts

@@ -3,20 +3,38 @@
  *
  * CRUD operations for posts with Thread support.
  * Posts have format (note/link/quote), status (draft/published),
- * featured flag, and pinned flag.
+ * visibility (public/unlisted/private), featuredAt, and pinnedAt timestamp.
  */
 
-import { eq, and, isNull, desc, or, inArray, sql } from "drizzle-orm";
+import { eq, and, isNull, desc, inArray, sql, isNotNull } from "drizzle-orm";
 import type { BatchItem } from "drizzle-orm/batch";
-import type { Database } from "../db/index.js";
-import { posts, postCollections } from "../db/schema.js";
+import { uuidv7 } from "uuidv7";
+import { type Database, batchQueryRows } from "../db/index.js";
+import { pathRegistry, posts, postCollections } from "../db/schema.js";
 import { now } from "../lib/time.js";
-import { render as renderMarkdown } from "../lib/markdown.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 { normalizePath, slugify } from "../lib/url.js";
 import type { StorageDriver } from "../lib/storage.js";
 import type { MediaService } from "./media.js";
-import type { Format, Status, Post, CreatePost, UpdatePost } from "../types.js";
-import type { PathRegistryService } from "./path-registry.js";
-import { ConflictError } from "../lib/errors.js";
+import type {
+  Format,
+  Status,
+  Visibility,
+  MediaKind,
+  Post,
+  CreatePost,
+  UpdatePost,
+  ThreadTimelineContext,
+} from "../types.js";
+import {
+  ConflictError,
+  ValidationError,
+  NotFoundError,
+} from "../lib/errors.js";
+import { createPathService, type PathService } from "./path.js";
 
 /** Dependencies for operations that coordinate with other services */
 export interface PostDeleteDeps {
@@ -27,26 +45,51 @@ export interface PostDeleteDeps {
 export interface PostFilters {
   format?: Format;
   status?: Status;
-  featured?: boolean;
+  visibility?: Visibility;
   pinned?: boolean;
-  collectionId?: number;
-  /** Exclude posts that are replies (have threadId set) */
+  featured?: boolean;
+  collectionId?: string;
+  /** Exclude posts that are replies (have replyToId set) */
   excludeReplies?: boolean;
+  /** Exclude unlisted posts from results */
+  excludeUnlisted?: boolean;
+  /** Exclude private posts from results */
+  excludePrivate?: boolean;
   includeDeleted?: boolean;
-  threadId?: number;
+  threadId?: string;
+  /** Unix timestamp (inclusive) — only posts published at or after this time */
+  publishedAfter?: number;
+  /** Unix timestamp (exclusive) — only posts published before this time */
+  publishedBefore?: number;
+  /** Media kinds to filter by (OR logic: post has media of ANY selected kind). */
+  mediaKinds?: MediaKind[];
+  /** Filter by media presence */
+  hasMedia?: boolean;
+  /** Filter by title presence */
+  hasTitle?: boolean;
   limit?: number;
-  cursor?: number; // post id for cursor pagination
+  cursor?: string; // post id for cursor pagination (UUIDv7 sorts chronologically)
   offset?: number; // offset for page-based pagination
 }
 
+/** Config for automatic summary extraction */
+export interface SummaryConfig {
+  maxParagraphs: number;
+  maxChars: number;
+}
+
 export interface PostService {
-  getById(id: number): Promise<Post | null>;
-  getByPath(path: string): Promise<Post | null>;
+  getById(id: string): Promise<Post | null>;
+  getBySlug(slug: string): Promise<Post | null>;
   list(filters?: PostFilters): Promise<Post[]>;
   /** Count posts matching filters (ignores cursor, offset, limit) */
   count(filters?: PostFilters): Promise<number>;
-  create(data: CreatePost): Promise<Post>;
-  update(id: number, data: UpdatePost): Promise<Post | null>;
+  create(data: CreatePost, summaryConfig?: SummaryConfig): Promise<Post>;
+  update(
+    id: string,
+    data: UpdatePost,
+    summaryConfig?: SummaryConfig,
+  ): Promise<Post | null>;
   /**
    * Soft-delete a post and clean up its media (storage files + DB records).
    * Thread roots cascade to all replies.
@@ -54,32 +97,151 @@ export interface PostService {
    * @param id - Post ID
    * @param deps - Media service and optional storage driver for file cleanup
    */
-  delete(id: number, deps?: PostDeleteDeps): Promise<boolean>;
-  getThread(rootId: number): Promise<Post[]>;
-  updateThreadStatusAndFeatured(
-    rootId: number,
+  delete(id: string, deps?: PostDeleteDeps): Promise<boolean>;
+  getThread(rootId: string): Promise<Post[]>;
+  updateThreadStatusAndVisibility(
+    rootId: string,
     status: Status,
-    featured: boolean,
+    visibility: Visibility,
   ): Promise<void>;
   /** Get reply counts for multiple posts */
-  getReplyCounts(postIds: number[]): Promise<Map<number, number>>;
+  getReplyCounts(postIds: string[]): Promise<Map<string, number>>;
   /** Get preview replies for multiple thread roots */
   getThreadPreviews(
-    rootIds: number[],
+    rootIds: string[],
     previewCount?: number,
-  ): Promise<Map<number, Post[]>>;
+  ): Promise<Map<string, Post[]>>;
+  /** Get latest-reply context for multiple thread roots (for timeline display) */
+  getThreadTimelineContext(
+    rootIds: string[],
+  ): Promise<Map<string, ThreadTimelineContext>>;
+  /** 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 */
+  getLastPostIdsByThread(threadIds: string[]): Promise<Map<string, string>>;
+}
+
+const SLUG_RE = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
+
+function isValidSlug(value: string): boolean {
+  return SLUG_RE.test(value);
 }
 
-/** Check if an error is a SQLite UNIQUE constraint violation (D1 or better-sqlite3) */
+/** Check if an error (or any of its causes) is a SQLite UNIQUE constraint violation */
 function isUniqueConstraintError(err: unknown): boolean {
-  const msg = String(err);
-  return msg.includes("UNIQUE constraint") || msg.includes("SQLITE_CONSTRAINT");
+  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;
+}
+
+function hasNonEmptyText(value: string | null | undefined): boolean {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function assertPostFormatShape(data: {
+  format: Format;
+  url?: string | null;
+  quoteText?: string | null;
+}): void {
+  const hasUrl = hasNonEmptyText(data.url);
+  const hasQuoteText = hasNonEmptyText(data.quoteText);
+
+  if (data.format === "note") {
+    if (hasUrl) {
+      throw new ValidationError("Notes can't include a URL.");
+    }
+    if (hasQuoteText) {
+      throw new ValidationError("Notes can't include quoted text.");
+    }
+    return;
+  }
+
+  if (data.format === "link") {
+    if (!hasUrl) {
+      throw new ValidationError("Link posts need a URL.");
+    }
+    if (hasQuoteText) {
+      throw new ValidationError("Link posts can't include quoted text.");
+    }
+    return;
+  }
+
+  if (!hasQuoteText) {
+    throw new ValidationError("Quote posts need quoted text.");
+  }
+}
+
+function isThreadReply(post: Pick<Post, "replyToId">): boolean {
+  return post.replyToId !== null;
+}
+
+function assertDraftPublishedAt(
+  status: Status,
+  publishedAt: number | undefined,
+): void {
+  if (status === "draft" && publishedAt !== undefined) {
+    throw new ValidationError("Drafts can't set a publish time.");
+  }
 }
 
 export function createPostService(
   db: Database,
-  pathRegistry: PathRegistryService,
+  config: { slugIdLength: number },
+  paths: PathService = createPathService(db),
 ): PostService {
+  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) */
+  async function isSlugAvailable(slug: string): Promise<boolean> {
+    return paths.isPathAvailable(slug);
+  }
+
+  async function pathExists(path: string): Promise<boolean> {
+    const rows = await db
+      .select({ id: pathRegistry.id })
+      .from(pathRegistry)
+      .where(eq(pathRegistry.path, normalizePath(path)))
+      .limit(1);
+    return rows.length > 0;
+  }
+
+  async function recalculateThreadLastActivity(rootId: string): Promise<void> {
+    const rootRows = await db
+      .select({
+        latestPublishedAt: sql<number | null>`MAX(${posts.publishedAt})`.as(
+          "latest_published_at",
+        ),
+      })
+      .from(posts)
+      .where(and(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))
+      .limit(1);
+
+    const lastActivityAt = latestPublishedAt ?? root[0]?.updatedAt ?? now();
+
+    await db.update(posts).set({ lastActivityAt }).where(eq(posts.id, rootId));
+  }
+
   /** Build WHERE conditions from filters (shared by list and count) */
   function buildFilterConditions(filters: PostFilters) {
     const conditions = [];
@@ -87,11 +249,28 @@ export function createPostService(
     if (filters.status) {
       conditions.push(eq(posts.status, filters.status));
     }
-    if (filters.featured !== undefined) {
-      conditions.push(eq(posts.featured, filters.featured ? 1 : 0));
+    if (filters.visibility !== undefined) {
+      conditions.push(sql`${effectiveVisibilityExpr} = ${filters.visibility}`);
+    }
+    if (filters.excludeUnlisted) {
+      conditions.push(sql`${effectiveVisibilityExpr} != 'unlisted'`);
+    }
+    if (filters.excludePrivate) {
+      conditions.push(sql`${effectiveVisibilityExpr} != 'private'`);
     }
     if (filters.pinned !== undefined) {
-      conditions.push(eq(posts.pinned, filters.pinned ? 1 : 0));
+      conditions.push(
+        filters.pinned
+          ? sql`${posts.pinnedAt} IS NOT NULL`
+          : isNull(posts.pinnedAt),
+      );
+    }
+    if (filters.featured !== undefined) {
+      conditions.push(
+        filters.featured
+          ? sql`${posts.featuredAt} IS NOT NULL`
+          : isNull(posts.featuredAt),
+      );
     }
     if (filters.format) {
       conditions.push(eq(posts.format, filters.format));
@@ -99,45 +278,136 @@ export function createPostService(
     if (filters.collectionId !== undefined) {
       // Filter by collection via junction table
       conditions.push(
-        sql`${posts.id} IN (SELECT post_id FROM post_collections WHERE collection_id = ${filters.collectionId})`,
+        sql`${posts.id} IN (SELECT post_id FROM post_collection WHERE collection_id = ${filters.collectionId})`,
       );
     }
     if (filters.threadId) {
       conditions.push(eq(posts.threadId, filters.threadId));
     }
     if (filters.excludeReplies) {
-      conditions.push(isNull(posts.threadId));
+      conditions.push(isNull(posts.replyToId));
     }
     if (!filters.includeDeleted) {
       conditions.push(isNull(posts.deletedAt));
     }
+    if (filters.publishedAfter !== undefined) {
+      conditions.push(sql`${posts.publishedAt} >= ${filters.publishedAfter}`);
+    }
+    if (filters.publishedBefore !== undefined) {
+      conditions.push(sql`${posts.publishedAt} < ${filters.publishedBefore}`);
+    }
+    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`, `)}))`,
+      );
+    }
+    if (filters.hasMedia !== undefined) {
+      if (filters.hasMedia) {
+        conditions.push(sql`${posts.id} IN (SELECT post_id FROM media)`);
+      } else {
+        conditions.push(sql`${posts.id} NOT IN (SELECT post_id FROM media)`);
+      }
+    }
+    if (filters.hasTitle !== undefined) {
+      if (filters.hasTitle) {
+        conditions.push(
+          sql`${posts.title} IS NOT NULL AND ${posts.title} != ''`,
+        );
+      } else {
+        conditions.push(sql`(${posts.title} IS NULL OR ${posts.title} = '')`);
+      }
+    }
 
     return conditions;
   }
 
-  function toPost(row: typeof posts.$inferSelect): Post {
+  function toPost(
+    row: typeof posts.$inferSelect,
+    slug: string,
+    visibility: Visibility,
+  ): Post {
     return {
       id: row.id,
       format: row.format as Format,
       status: row.status as Status,
-      featured: row.featured,
-      pinned: row.pinned,
-      path: row.path,
+      visibility,
+      pinnedAt: row.pinnedAt,
+      featuredAt: row.featuredAt,
+      slug,
       title: row.title,
       url: row.url,
       body: row.body,
       bodyHtml: row.bodyHtml,
+      bodyText: row.bodyText,
       quoteText: row.quoteText,
+      summary: row.summary,
       rating: row.rating,
       replyToId: row.replyToId,
       threadId: row.threadId,
       deletedAt: row.deletedAt,
       publishedAt: row.publishedAt,
+      lastActivityAt: row.lastActivityAt ?? row.publishedAt ?? row.updatedAt,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
     };
   }
 
+  async function hydratePost(
+    row: typeof posts.$inferSelect | undefined,
+  ): Promise<Post | null> {
+    if (!row) return null;
+    const slug = await paths.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);
+  }
+
+  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 rootVisibilityMap = await getThreadVisibilityMap(
+      rows.map((row) => row.threadId),
+    );
+    return rows
+      .map((row) => {
+        const slug = slugMap.get(row.id);
+        const visibility =
+          rootVisibilityMap.get(row.threadId) ?? row.visibility;
+        return slug && visibility
+          ? toPost(row, slug, visibility as Visibility)
+          : null;
+      })
+      .filter((row): row is Post => row !== null);
+  }
+
+  async function getThreadVisibilityMap(
+    threadIds: string[],
+  ): Promise<Map<string, Visibility>> {
+    const uniqueThreadIds = [...new Set(threadIds)];
+    const result = new Map<string, Visibility>();
+    if (uniqueThreadIds.length === 0) return result;
+
+    const rows = await batchQueryRows(uniqueThreadIds, (chunk) =>
+      db
+        .select({ id: posts.id, visibility: posts.visibility })
+        .from(posts)
+        .where(inArray(posts.id, chunk)),
+    );
+
+    for (const row of rows) {
+      if (row.visibility) {
+        result.set(row.id, row.visibility as Visibility);
+      }
+    }
+
+    return result;
+  }
+
   return {
     async getById(id) {
       const result = await db
@@ -145,20 +415,28 @@ export function createPostService(
         .from(posts)
         .where(and(eq(posts.id, id), isNull(posts.deletedAt)))
         .limit(1);
-      return result[0] ? toPost(result[0]) : null;
+      return hydratePost(result[0]);
     },
 
-    async getByPath(path) {
-      const result = await db
-        .select()
-        .from(posts)
-        .where(and(eq(posts.path, path), isNull(posts.deletedAt)))
-        .limit(1);
-      return result[0] ? toPost(result[0]) : null;
+    async getBySlug(slug) {
+      const resolved = await paths.resolve(slug);
+      if (!resolved || resolved.kind !== "slug" || !resolved.postId) {
+        return null;
+      }
+      return this.getById(resolved.postId);
     },
 
     async list(filters = {}) {
       const conditions = buildFilterConditions(filters);
+      const sortTimestamp =
+        filters.status === "draft"
+          ? posts.updatedAt
+          : filters.status === "published"
+            ? posts.lastActivityAt
+            : sql<number>`CASE
+                WHEN ${posts.status} = 'draft' THEN ${posts.updatedAt}
+                ELSE ${posts.lastActivityAt}
+              END`;
 
       if (filters.cursor) {
         conditions.push(sql`${posts.id} < ${filters.cursor}`);
@@ -168,7 +446,11 @@ export function createPostService(
         .select()
         .from(posts)
         .where(conditions.length > 0 ? and(...conditions) : undefined)
-        .orderBy(desc(posts.publishedAt), desc(posts.id))
+        .orderBy(
+          desc(posts.pinnedAt),
+          filters.featured ? desc(posts.featuredAt) : desc(sortTimestamp),
+          desc(posts.id),
+        )
         .limit(filters.limit ?? 100);
 
       if (filters.offset !== undefined) {
@@ -176,7 +458,7 @@ export function createPostService(
       }
 
       const rows = await query;
-      return rows.map(toPost);
+      return hydratePosts(rows);
     },
 
     async count(filters = {}) {
@@ -190,144 +472,331 @@ export function createPostService(
       return result[0]?.count ?? 0;
     },
 
-    async create(data) {
+    async create(data, summaryConfig) {
+      const id = uuidv7();
       const timestamp = now();
 
-      const bodyHtml = data.body ? renderMarkdown(data.body) : null;
+      assertPostFormatShape({
+        format: data.format,
+        url: data.url,
+        quoteText: data.quoteText,
+      });
+
+      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 (data.format === "note" && data.title && body && summaryConfig) {
+        summary = extractSummary(
+          body,
+          summaryConfig.maxParagraphs,
+          summaryConfig.maxChars,
+        );
+      }
 
       // Handle thread relationship
-      let threadId: number | null = null;
+      let threadId = id;
       let status: Status = data.status ?? "published";
-      let featured = data.featured ?? false;
+      let visibility: Visibility | null = data.visibility ?? "public";
 
       if (data.replyToId) {
         const parent = await this.getById(data.replyToId);
-        if (parent) {
-          threadId = parent.threadId ?? parent.id;
-          // Inherit status and featured from root
-          const root = parent.threadId
-            ? await this.getById(parent.threadId)
-            : parent;
-          if (root) {
+        if (!parent) {
+          throw new NotFoundError("Parent post");
+        }
+
+        if (data.pinned) {
+          throw new ConflictError(
+            "Cannot pin a thread reply. Pin the root post instead.",
+          );
+        }
+
+        threadId = parent.threadId;
+
+        // Replies inherit visibility from the root at read time.
+        const root =
+          parent.threadId === parent.id
+            ? parent
+            : await this.getById(parent.threadId);
+        if (root) {
+          if (data.status !== "draft") {
             status = root.status as Status;
-            featured = root.featured === 1;
           }
         }
+        visibility = null;
       }
 
-      // Validate path availability before DB insert — throws friendly
-      // ConflictError/ValidationError instead of a raw UNIQUE constraint error.
-      // Uses placeholder owner ID; corrected to real ID after insert.
+      assertDraftPublishedAt(status, data.publishedAt);
+      const publishedAt =
+        status === "published" ? (data.publishedAt ?? timestamp) : null;
+
+      // Resolve slug from slug, path, or title
+      let slug: string;
+      let aliasPath: string | null = null;
+
       if (data.path) {
-        await pathRegistry.claim(data.path, "post", 0);
+        const normalized = normalizePath(data.path);
+        if (isValidSlug(normalized)) {
+          // Path is a valid slug — use it directly
+          slug = await generatePostSlug({
+            slug: normalized,
+            idLength: config.slugIdLength,
+            isAvailable: isSlugAvailable,
+          });
+        } else {
+          // Path is not a valid slug — slugify it for the slug, keep original as alias
+          const slugified = slugify(normalized);
+          slug = await generatePostSlug({
+            slug: slugified || undefined,
+            title: data.title,
+            idLength: config.slugIdLength,
+            isAvailable: isSlugAvailable,
+          });
+          // Verify the alias path is available before proceeding
+          if (!(await paths.isPathAvailable(normalized))) {
+            throw new ConflictError(`Path "${normalized}" is already in use`);
+          }
+          aliasPath = normalized;
+        }
+      } else {
+        slug = await generatePostSlug({
+          slug: data.slug,
+          title: data.title,
+          idLength: config.slugIdLength,
+          isAvailable: isSlugAvailable,
+        });
       }
 
-      let result;
+      const collectionIds = [...new Set(data.collectionIds ?? [])];
+
       try {
-        result = await db
-          .insert(posts)
-          .values({
+        const writeQueries: BatchItem<"sqlite">[] = [
+          db.insert(posts).values({
+            id,
             format: data.format,
             status,
-            featured: featured ? 1 : 0,
-            pinned: data.pinned ? 1 : 0,
-            path: data.path ?? null,
+            visibility,
+            pinnedAt: data.pinned ? timestamp : null,
+            featuredAt: data.featured ? timestamp : null,
             title: data.title ?? null,
             url: data.url ?? null,
-            body: data.body ?? null,
+            body: body ?? null,
             bodyHtml,
+            bodyText,
             quoteText: data.quoteText ?? null,
+            summary,
             rating: data.rating ?? null,
             replyToId: data.replyToId ?? null,
             threadId,
-            publishedAt: data.publishedAt ?? timestamp,
+            publishedAt,
+            lastActivityAt: publishedAt ?? timestamp,
             createdAt: timestamp,
             updatedAt: timestamp,
-          })
-          .returning();
+          }),
+          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) {
+          writeQueries.push(
+            db.insert(pathRegistry).values({
+              id: uuidv7(),
+              path: normalizePath(aliasPath),
+              kind: "alias",
+              postId: id,
+              collectionId: null,
+              redirectToPath: null,
+              redirectType: null,
+              createdAt: timestamp,
+              updatedAt: timestamp,
+            }),
+          );
+        }
+
+        if (collectionIds.length > 0) {
+          writeQueries.push(
+            db.insert(postCollections).values(
+              collectionIds.map((collectionId) => ({
+                postId: id,
+                collectionId,
+                createdAt: timestamp,
+              })),
+            ),
+          );
+        }
+
+        await db.batch(
+          writeQueries as [
+            (typeof writeQueries)[number],
+            ...(typeof writeQueries)[number][],
+          ],
+        );
       } catch (err) {
-        if (data.path) await pathRegistry.release(data.path);
-        if (isUniqueConstraintError(err)) {
-          throw new ConflictError(`Path "${data.path}" is already in use`);
+        if (err instanceof ConflictError) {
+          throw new ConflictError(`Slug "${slug}" is already in use`);
+        }
+        if (isUniqueConstraintError(err) && (await pathExists(slug))) {
+          throw new ConflictError(`Slug "${slug}" is already in use`);
         }
         throw err;
       }
 
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- DB insert with .returning() always returns inserted row
-      const post = toPost(result[0]!);
-
-      // Update registry with actual post ID
-      if (post.path) {
-        await pathRegistry.release(post.path);
-        await pathRegistry.claim(post.path, "post", post.id);
+      const post = await this.getById(id);
+      if (!post) {
+        throw new ConflictError(`Slug "${slug}" could not be resolved`);
       }
 
-      // Sync collection memberships if provided
-      if (data.collectionIds && data.collectionIds.length > 0) {
-        await db.insert(postCollections).values(
-          data.collectionIds.map((collectionId) => ({
-            postId: post.id,
-            collectionId,
-          })),
-        );
+      // Bump thread root's lastActivityAt when creating a published reply
+      if (data.replyToId && status === "published") {
+        await recalculateThreadLastActivity(threadId);
       }
 
       return post;
     },
 
-    async update(id, data) {
+    async update(id, data, summaryConfig) {
       const existing = await this.getById(id);
       if (!existing) return null;
 
-      // Handle path changes in the registry before modifying the post
-      const pathChanging =
-        data.path !== undefined && data.path !== existing.path;
-      if (pathChanging) {
-        // Claim new path (if non-null) before releasing old
-        if (data.path) {
-          await pathRegistry.claim(data.path, "post", id);
-        }
-        // Release old path (if it existed)
-        if (existing.path) {
-          await pathRegistry.release(existing.path);
-        }
-      }
-
       const timestamp = now();
+      const nextFormat = 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;
+
+      assertPostFormatShape({
+        format: nextFormat,
+        url: nextUrl,
+        quoteText: nextQuoteText,
+      });
+      assertDraftPublishedAt(nextStatus, data.publishedAt);
+
       const updates: Partial<typeof posts.$inferInsert> = {
         updatedAt: timestamp,
       };
 
+      // Handle slug change
+      const slugChanged =
+        data.slug !== undefined && data.slug !== existing.slug;
+      if (slugChanged && data.slug) {
+        try {
+          await paths.updatePostSlug(id, data.slug);
+        } catch (err) {
+          if (err instanceof ConflictError) {
+            throw new ConflictError(`Slug "${data.slug}" is already in use`);
+          }
+          throw err;
+        }
+      }
+
       if (data.format !== undefined) updates.format = data.format;
-      if (data.path !== undefined) updates.path = data.path;
       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.publishedAt !== undefined)
-        updates.publishedAt = data.publishedAt;
-      if (data.pinned !== undefined) updates.pinned = data.pinned ? 1 : 0;
+      if (data.pinned !== undefined)
+        updates.pinnedAt = data.pinned ? now() : null;
+      if (data.featured !== undefined)
+        updates.featuredAt = data.featured ? now() : null;
+
+      if (data.body !== undefined || data.bodyMarkdown !== undefined) {
+        const normalizedBody = data.bodyMarkdown
+          ? markdownToTiptapJson(data.bodyMarkdown)
+          : (data.body ?? null);
+        updates.body = normalizedBody;
+        updates.bodyHtml = normalizedBody
+          ? renderTiptapJson(normalizedBody)
+          : null;
+        updates.bodyText = normalizedBody
+          ? extractBodyText(normalizedBody)
+          : null;
+      }
+
+      // Recompute summary when body, title, or format change
+      if (summaryConfig) {
+        const format = data.format ?? (existing.format as Format);
+        const title = data.title !== undefined ? data.title : existing.title;
+        const body =
+          data.bodyMarkdown !== undefined
+            ? data.bodyMarkdown
+              ? markdownToTiptapJson(data.bodyMarkdown)
+              : null
+            : data.body !== undefined
+              ? data.body
+              : existing.body;
+        if (format === "note" && title && body) {
+          updates.summary = extractSummary(
+            body,
+            summaryConfig.maxParagraphs,
+            summaryConfig.maxChars,
+          );
+        } else {
+          updates.summary = null;
+        }
+      }
 
-      if (data.body !== undefined) {
-        updates.body = data.body;
-        updates.bodyHtml = data.body ? renderMarkdown(data.body) : null;
+      // Thread replies inherit visibility/pinned from root — reject direct changes
+      if (isThreadReply(existing)) {
+        if (data.visibility !== undefined) {
+          throw new ConflictError(
+            "Cannot change visibility of a thread reply. Update the root post instead.",
+          );
+        }
+        if (data.pinned !== undefined) {
+          throw new ConflictError(
+            "Cannot pin a thread reply. Pin the root post instead.",
+          );
+        }
       }
 
-      // Handle status/featured change - cascade to thread if this is root
+      // Handle status/visibility change - cascade to thread if this is root
       const statusChanged =
         data.status !== undefined && data.status !== existing.status;
-      const featuredChanged =
-        data.featured !== undefined &&
-        (data.featured ? 1 : 0) !== existing.featured;
+      const visibilityChanged =
+        data.visibility !== undefined &&
+        data.visibility !== existing.visibility;
+      const publishedAtChanged = data.publishedAt !== undefined;
+      const nextPublishedAt =
+        nextStatus === "draft"
+          ? null
+          : publishedAtChanged
+            ? (data.publishedAt ?? timestamp)
+            : existing.status === "draft"
+              ? timestamp
+              : (existing.publishedAt ?? timestamp);
 
       if (statusChanged) updates.status = data.status;
-      if (featuredChanged) updates.featured = data.featured ? 1 : 0;
+      if (visibilityChanged && !isThreadReply(existing)) {
+        updates.visibility = data.visibility;
+      }
+      if (statusChanged || publishedAtChanged || existing.status === "draft") {
+        updates.publishedAt = nextPublishedAt;
+        updates.lastActivityAt = nextPublishedAt ?? timestamp;
+      }
 
       // Build all write queries for atomic execution via D1 batch
-      const needsCascade =
-        (statusChanged || featuredChanged) && !existing.threadId;
+      const needsCascade = statusChanged && !isThreadReply(existing);
+      const needsReplyVisibilityCleanup =
+        !isThreadReply(existing) && (statusChanged || visibilityChanged);
       const needsCollectionSync = data.collectionIds !== undefined;
-      const hasExtraWrites = needsCascade || needsCollectionSync;
+      const needsThreadActivityRecalc =
+        statusChanged || publishedAtChanged || existing.status === "draft";
+      const hasExtraWrites =
+        needsCascade || needsReplyVisibilityCleanup || needsCollectionSync;
 
       if (!hasExtraWrites) {
         // Simple case: only the post update
@@ -336,7 +805,11 @@ export function createPostService(
           .set(updates)
           .where(eq(posts.id, id))
           .returning();
-        return result[0] ? toPost(result[0]) : null;
+        if (needsThreadActivityRecalc) {
+          await recalculateThreadLastActivity(existing.threadId);
+          return this.getById(id);
+        }
+        return hydratePost(result[0]);
       }
 
       // Complex case: batch cascade + update + collection sync atomically
@@ -348,16 +821,23 @@ export function createPostService(
             .update(posts)
             .set({
               status: data.status ?? (existing.status as Status),
-              featured: (
-                data.featured !== undefined
-                  ? data.featured
-                  : existing.featured === 1
-              )
-                ? 1
-                : 0,
+              publishedAt: nextStatus === "published" ? nextPublishedAt : null,
+              lastActivityAt:
+                nextStatus === "published"
+                  ? (nextPublishedAt ?? timestamp)
+                  : timestamp,
               updatedAt: timestamp,
             })
-            .where(eq(posts.threadId, id)),
+            .where(and(eq(posts.threadId, id), isNotNull(posts.replyToId))),
+        );
+      }
+
+      if (needsReplyVisibilityCleanup) {
+        writeQueries.push(
+          db
+            .update(posts)
+            .set({ visibility: null, updatedAt: timestamp })
+            .where(and(eq(posts.threadId, id), isNotNull(posts.replyToId))),
         );
       }
 
@@ -379,6 +859,7 @@ export function createPostService(
               data.collectionIds!.map((collectionId) => ({
                 postId: id,
                 collectionId,
+                createdAt: now(),
               })),
             ),
           );
@@ -394,7 +875,11 @@ export function createPostService(
       const updateResult = results[updateIdx] as
         | (typeof posts.$inferSelect)[]
         | undefined;
-      return updateResult?.[0] ? toPost(updateResult[0]) : null;
+      if (needsThreadActivityRecalc) {
+        await recalculateThreadLastActivity(existing.threadId);
+        return this.getById(id);
+      }
+      return hydratePost(updateResult?.[0]);
     },
 
     async delete(id, deps) {
@@ -403,8 +888,8 @@ export function createPostService(
 
       // Clean up media for all affected posts
       if (deps?.media) {
-        let postIds: number[];
-        if (!existing.threadId) {
+        let postIds: string[];
+        if (!isThreadReply(existing)) {
           const thread = await this.getThread(id);
           postIds = thread.map((p) => p.id);
         } else {
@@ -421,32 +906,21 @@ export function createPostService(
         }
       }
 
-      // Release paths from registry
-      if (!existing.threadId) {
-        // Thread root: release paths for all posts in thread
-        const thread = await this.getThread(id);
-        for (const post of thread) {
-          if (post.path) {
-            await pathRegistry.release(post.path);
-          }
-        }
-      } else if (existing.path) {
-        await pathRegistry.release(existing.path);
-      }
-
       const timestamp = now();
 
       // If this is a thread root, soft delete all posts in the thread
-      if (!existing.threadId) {
+      if (!isThreadReply(existing)) {
         await db
           .update(posts)
           .set({ deletedAt: timestamp, updatedAt: timestamp })
-          .where(or(eq(posts.id, id), eq(posts.threadId, id)));
+          .where(eq(posts.threadId, id));
       } else {
+        // Soft-delete the single reply
         await db
           .update(posts)
           .set({ deletedAt: timestamp, updatedAt: timestamp })
           .where(eq(posts.id, id));
+        await recalculateThreadLastActivity(existing.threadId);
       }
 
       return true;
@@ -456,23 +930,37 @@ export function createPostService(
       const rows = await db
         .select()
         .from(posts)
-        .where(
-          and(
-            or(eq(posts.id, rootId), eq(posts.threadId, rootId)),
-            isNull(posts.deletedAt),
-          ),
-        )
+        .where(and(eq(posts.threadId, rootId), isNull(posts.deletedAt)))
         .orderBy(posts.createdAt);
 
-      return rows.map(toPost);
+      return hydratePosts(rows);
     },
 
-    async updateThreadStatusAndFeatured(rootId, status, featured) {
+    async updateThreadStatusAndVisibility(rootId, status, visibility) {
       const timestamp = now();
-      await db
-        .update(posts)
-        .set({ status, featured: featured ? 1 : 0, updatedAt: timestamp })
-        .where(eq(posts.threadId, rootId));
+      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))),
+      ]);
+      await recalculateThreadLastActivity(rootId);
     },
 
     async getReplyCounts(postIds) {
@@ -484,14 +972,19 @@ export function createPostService(
           count: sql<number>`count(*)`.as("count"),
         })
         .from(posts)
-        .where(and(inArray(posts.threadId, postIds), isNull(posts.deletedAt)))
+        .where(
+          and(
+            inArray(posts.threadId, postIds),
+            eq(posts.status, "published"),
+            isNotNull(posts.replyToId),
+            isNull(posts.deletedAt),
+          ),
+        )
         .groupBy(posts.threadId);
 
-      const counts = new Map<number, number>();
+      const counts = new Map<string, number>();
       for (const row of rows) {
-        if (row.threadId !== null) {
-          counts.set(row.threadId, row.count);
-        }
+        counts.set(row.threadId, row.count);
       }
       return counts;
     },
@@ -502,13 +995,18 @@ export function createPostService(
       const rows = await db
         .select()
         .from(posts)
-        .where(and(inArray(posts.threadId, rootIds), isNull(posts.deletedAt)))
+        .where(
+          and(
+            inArray(posts.threadId, rootIds),
+            eq(posts.status, "published"),
+            isNotNull(posts.replyToId),
+            isNull(posts.deletedAt),
+          ),
+        )
         .orderBy(posts.threadId, posts.createdAt);
 
-      const result = new Map<number, Post[]>();
-      for (const row of rows) {
-        const post = toPost(row);
-        if (post.threadId === null) continue;
+      const result = new Map<string, Post[]>();
+      for (const post of await hydratePosts(rows)) {
         const list = result.get(post.threadId);
         if (list) {
           if (list.length < previewCount) {
@@ -520,5 +1018,99 @@ export function createPostService(
       }
       return result;
     },
+
+    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()
+        .from(posts)
+        .where(
+          and(
+            inArray(posts.threadId, rootIds),
+            eq(posts.status, "published"),
+            isNotNull(posts.replyToId),
+            isNull(posts.deletedAt),
+          ),
+        )
+        .orderBy(posts.threadId, desc(posts.createdAt), desc(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);
+        } else {
+          grouped.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;
+        }
+
+        result.set(threadId, { latestReply, parentReply, totalReplyCount });
+      }
+
+      return result;
+    },
+
+    async getLastPostIdsByThread(threadIds) {
+      const result = new Map<string, string>();
+      if (threadIds.length === 0) return result;
+
+      const unique = [...new Set(threadIds)];
+      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"),
+        })
+        .from(posts)
+        .where(inArray(posts.id, unique));
+
+      for (const row of rows) {
+        if (row.id) result.set(row.threadId, row.id);
+      }
+      return result;
+    },
+
+    async getDistinctYears(filters = {}) {
+      const conditions = [
+        ...buildFilterConditions(filters),
+        isNotNull(posts.publishedAt),
+      ];
+
+      const rows = await db
+        .select({
+          year: sql<string>`strftime('%Y', ${posts.publishedAt}, 'unixepoch')`.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')`));
+
+      return rows.map((r) => parseInt(r.year, 10));
+    },
   };
 }