@jant/core 0.6.16 → 0.7.1

package/src/services/post.ts

@@ -15,6 +15,7 @@ import {
   isNull,
   desc,
   inArray,
+  notInArray,
   sql,
   isNotNull,
   asc,
@@ -36,6 +37,7 @@ import {
   buildRootActivityExpr,
   rootActivityColumns,
 } from "../db/thread-activity.js";
+import { buildReaderVisibilityConditions } from "../db/post-visibility.js";
 import { createEntityId } from "../lib/ids.js";
 import { now } from "../lib/time.js";
 import { trimTiptapBody } from "../lib/tiptap-render.js";
@@ -46,12 +48,17 @@ import {
   tryPreparePostBodyHtml,
 } from "../lib/post-body-html.js";
 import { extractSummary, extractBodyText } from "../lib/summary.js";
+import {
+  THREAD_LEADING_REPLIES,
+  THREAD_TRAILING_REPLIES,
+} from "../lib/thread-fold.js";
 import { markdownToTiptapJson } from "../lib/markdown-to-tiptap.js";
 import { tiptapJsonToMarkdown } from "../lib/tiptap-to-markdown.js";
 import { generatePostSlug } from "../lib/slug.js";
 import { getSlugValidationIssue } from "../lib/slug-format.js";
 import { isReservedPath } from "../lib/constants.js";
-import { normalizePath, slugify } from "../lib/url.js";
+import { normalizePath } from "../lib/url.js";
+import { slugify } from "../lib/slugify.js";
 import type { StorageDriver } from "../lib/storage.js";
 import type { MediaService } from "./media.js";
 import {
@@ -78,6 +85,14 @@ import {
   ValidationError,
   NotFoundError,
 } from "../lib/errors.js";
+import {
+  isValidContentLanguage,
+  normalizeContentLanguage,
+  toLanguagePrefix,
+} from "../i18n/locales.js";
+import { readLanguageSettings } from "./language.js";
+import { getOrBuildEntry } from "../i18n/supported-locales.js";
+import { suggestPostLanguage } from "../lib/lang-detect.js";
 import { createPathService, type PathService } from "./path.js";
 import {
   extractYouTubeVideoId,
@@ -141,6 +156,12 @@ export interface PostFilters {
   /** Exclude private posts from results */
   excludePrivate?: boolean;
   threadId?: string;
+  /**
+   * Restrict to these Posts. The list becomes one `IN (…)`, so a caller keeps
+   * it within a single statement's parameter budget — 50 is what D1 leaves
+   * room for beside the other conditions.
+   */
+  ids?: string[];
   /** Unix timestamp (inclusive) — only posts published at or after this time */
   publishedAfter?: number;
   /** Unix timestamp (exclusive) — only posts published before this time */
@@ -155,6 +176,16 @@ export interface PostFilters {
   axisBefore?: number;
   /** Media kinds to filter by (OR logic: post has media of ANY selected kind). */
   mediaKinds?: MediaKind[];
+  /**
+   * Restrict to one BCP 47 content language (canonical form, matched exactly).
+   *
+   * A plain column predicate is correct at every grain because `post.language`
+   * is uniform across a Thread — replies inherit the Root's value and a
+   * language change rewrites the whole Thread. It rides along as a residual
+   * predicate on the existing hot-path partial indexes rather than getting its
+   * own index; see the multilingual design notes for the upgrade path.
+   */
+  lang?: string;
   /** Filter by media presence */
   hasMedia?: boolean;
   /** Filter by title presence */
@@ -189,18 +220,29 @@ export interface PostFilters {
   offset?: number; // offset for page-based pagination
 }
 
+/** What one filter measured over a set of Posts. See `aggregateMany`. */
+export interface PostFilterAggregate {
+  count: number;
+  /** Newest activity among the matched rows; `null` when nothing matched. */
+  recentActivityAt: number | null;
+}
+
 /** Config for automatic summary extraction */
 export interface SummaryConfig {
   maxParagraphs: number;
   maxChars: number;
 }
 
-interface ThreadRootPageOptions {
+export interface ThreadRootPageOptions {
   status?: Status;
   excludePrivate?: boolean;
   excludeLatestHidden?: boolean;
+  /** See `PostFilters.lang`. */
+  lang?: string;
   /** Exclude Posts published at or after this Unix timestamp. */
   publishedBefore?: number;
+  /** Restrict to these Threads, by root ID. Same budget as `PostFilters.ids`. */
+  threadIds?: string[];
   /** Restrict by the Thread root's format without excluding Child Posts. */
   rootFormat?: Format;
   /** Restrict to Threads with at least one rated published post. */
@@ -233,7 +275,7 @@ export interface CollectionFeedEntry {
 
 export interface FeaturedThreadTimelinePost {
   post: Post;
-  /** Zero-based position among the Thread's published Posts. */
+  /** Zero-based position among the Thread's published Posts; the root is 0. */
   position: number;
 }
 
@@ -267,10 +309,72 @@ export interface SitemapPostEntry {
   alias: string | null;
   updatedAt: number;
   featuredAt: number | null;
+  /** Content language, when the post has one. */
+  language: string | null;
+  /** Translation group, used to emit sitemap `hreflang` alternates. */
+  translationGroupId: string | null;
+}
+
+/**
+ * What an address the author pasted turned out to be, for the one question the
+ * translation picker asks: can this Thread be linked to that one?
+ *
+ * Every "no" carries which one it is, because the author is looking at a page
+ * they know exists and needs to be told what is wrong with it, not that the
+ * search found nothing.
+ */
+export type TranslationCandidateResolution =
+  /** Linkable: the Thread root the address names. */
+  | { status: "ok"; post: Post }
+  /** No page at that address — a typo, or something since deleted. */
+  | { status: "not_found" }
+  /** A real page, but a collection or an archive rather than a Post. */
+  | { status: "not_a_post" }
+  /** The Thread the author is already linking from. */
+  | { status: "same_thread" }
+  | { status: "unpublished" }
+  /** Nothing to translate between until it has a language. */
+  | { status: "no_language" }
+  /** Written in the same language as this Thread. */
+  | { status: "same_language" }
+  /** A Thread already linked here speaks for that language. */
+  | { status: "language_taken"; language: string }
+  /** Both sides carry a group; linking would silently merge them. */
+  | { status: "group_conflict" }
+  /** Its group already holds this Thread's language. */
+  | { status: "group_language_taken"; language: string };
+
+/** A Post together with the custom URL that has taken over as its address. */
+export interface PostWithCanonicalAlias {
+  post: Post;
+  /**
+   * The newest registered `alias`, which is the address a slug URL redirects
+   * to. Null when the Post still answers at its slug.
+   */
+  canonicalAlias: string | null;
 }
 
 export interface PostService {
   getById(id: string): Promise<Post | null>;
+  /**
+   * The Post a resolved path points at, plus its canonical address, in one
+   * read.
+   *
+   * Serving a Post URL needs three things the registry and the Post row hold
+   * between them: the row, the Post's slug, and whether a custom URL has taken
+   * over as its address. Asking for those separately put three round trips at
+   * the head of every Post page, so they come back together.
+   *
+   * @param postId - TypeID of the Post
+   * @returns The hydrated Post and its canonical alias, or null when no such
+   *   Post exists or it has no slug
+   * @example
+   * ```ts
+   * const loaded = await posts.getWithCanonicalAlias(resolved.postId);
+   * if (loaded?.canonicalAlias) redirect(loaded.canonicalAlias);
+   * ```
+   */
+  getWithCanonicalAlias(postId: string): Promise<PostWithCanonicalAlias | null>;
   getBodyContent(id: string): Promise<PostBodyContent | null>;
   getBySlug(slug: string): Promise<Post | null>;
   suggestSlug(input: {
@@ -313,6 +417,38 @@ export interface PostService {
   count(filters?: PostFilters): Promise<number>;
   /** Count posts matching filters up to a fixed limit (ignores cursor, offset, limit) */
   countUpTo(filters: PostFilters | undefined, limit: number): Promise<number>;
+  /**
+   * Measure several filters at once, in a single round trip.
+   *
+   * One table scan with one `SUM(CASE …)` and one `MAX(CASE …)` per filter,
+   * rather than one query per filter. On Workers the round trip is the cost
+   * that matters, and a page that lists twenty smart collections would
+   * otherwise pay twenty of them — `Promise.all` only turns "slow in sequence"
+   * into "expensive in parallel".
+   *
+   * Every predicate is built by the same `buildFilterConditions` a single
+   * `count` uses, so the numbers here and the numbers on the pages they link to
+   * cannot drift.
+   *
+   * `recentActivityAt` is the newest activity among the matched rows, on the
+   * one definition {@link buildRootActivityExpr} holds for everything that
+   * orders or dates a Thread. It reads the matched row's own columns, so it
+   * describes a Thread only when `base` excludes replies — which is what every
+   * caller does, because a reply is not a member of anything.
+   *
+   * @param filters - One filter per measurement, in order
+   * @param base - Applied to every measurement: the site, the reader's
+   *   visibility floor, and anything else common to all of them
+   * @returns Count and newest activity, positionally matching `filters`;
+   *   `recentActivityAt` is `null` where nothing matched
+   * @example
+   * await posts.aggregateMany([{ format: "note" }, { format: "quote" }], base);
+   * // [{ count: 12, recentActivityAt: 1706100000 }, { count: 5, … }]
+   */
+  aggregateMany(
+    filters: readonly PostFilters[],
+    base: PostFilters,
+  ): Promise<PostFilterAggregate[]>;
   /** Count posts grouped by year-month (YYYY-MM) on the `sortBy` time axis */
   countByYearMonth(
     filters?: PostFilters,
@@ -369,6 +505,10 @@ export interface PostService {
    * Used when replacing a saved thread draft with a new version.
    */
   deleteThreadDraft(id: string, deps?: PostDeleteDeps): Promise<boolean>;
+  /**
+   * Every Post in a Thread, drafts included, in Thread order: the root first,
+   * then replies by creation time, then ID.
+   */
   getThread(rootId: string): Promise<Post[]>;
   /**
    * 1-based position of a Post in the reply chain running from its Thread root
@@ -390,6 +530,112 @@ export interface PostService {
     status: Status,
     visibility: Visibility,
   ): Promise<void>;
+  /**
+   * Set the content language of a whole Thread (root and every reply).
+   *
+   * Thread-wide by design: `post.language` is uniform inside a Thread, which is
+   * what lets every language filter stay a plain column predicate. Rejects a
+   * language another Post in the same translation group already holds.
+   *
+   * @param postId - Any Post in the Thread; the Thread is resolved from it
+   * @param language - Canonical BCP 47 tag
+   * @throws {NotFoundError} When no such Post exists on this site
+   * @throws {ConflictError} When the translation group already has that language
+   * @example
+   * await posts.setThreadLanguage(post.id, "zh-Hans");
+   */
+  setThreadLanguage(postId: string, language: string): Promise<void>;
+  /**
+   * Stamp every Post that has no language yet with `language`.
+   *
+   * Runs once when an author turns multilingual content on, and is idempotent
+   * so re-enabling later only touches Posts written while it was off. Scoped to
+   * this site — hosted deployments share one database.
+   *
+   * @param language - Canonical BCP 47 tag of the site's primary language
+   * @returns Number of Posts stamped
+   * @example
+   * await posts.materializeMissingLanguage("zh-Hans"); // => 347
+   */
+  materializeMissingLanguage(language: string): Promise<number>;
+  /** Count Posts on this site that still have no language. */
+  countMissingLanguage(): Promise<number>;
+  /** Count Posts on this site written in `language`, drafts included. */
+  countByLanguage(language: string): Promise<number>;
+  /**
+   * Every language stamped on this site's Posts, with how many carry it.
+   * Drafts included; the pre-multilingual NULL rows are not.
+   */
+  listLanguagesInUse(): Promise<Array<{ language: string; count: number }>>;
+  /**
+   * List the Thread roots that are translations of the given Post, excluding
+   * the Post itself. Empty when it belongs to no translation group.
+   */
+  listTranslations(postId: string): Promise<Post[]>;
+  /**
+   * List translations for many Thread roots in one round trip, keyed by the
+   * root ID that was asked about. Roots with no group are omitted.
+   */
+  getTranslationsMap(postIds: string[]): Promise<Map<string, Post[]>>;
+  /**
+   * Find published Thread roots this Post could be linked to as a translation.
+   *
+   * Filtered server-side rather than in the menu, because "can these two be
+   * linked" is a rule the service owns: a candidate has to be a Thread root in
+   * a language this Post's translation group does not already hold, and the two
+   * groups must not both exist — `linkTranslation` refuses to merge them.
+   * Offering a post that will be rejected teaches the author nothing.
+   *
+   * The match is a plain substring scan over title and body text. It is a
+   * deliberate, authenticated action over one author's own posts, so the cost
+   * is bounded and the shared search index (which cannot express these filters)
+   * is not worth involving.
+   *
+   * @param postId - Any Post in the Thread looking for a translation
+   * @param options - Search text and how many candidates to return
+   * @returns Matching Thread roots, newest first
+   * @example
+   * await posts.listTranslationCandidates(id, { query: "recipe" });
+   */
+  listTranslationCandidates(
+    postId: string,
+    options: { query: string; limit?: number },
+  ): Promise<Post[]>;
+  /**
+   * Resolve an address the author pasted into the Thread it names, and say
+   * whether this Post could be linked to it as a translation.
+   *
+   * The same rules as {@link PostService.listTranslationCandidates}, asked
+   * about one known Thread instead of searched for — so the answer can be a
+   * reason rather than an empty list. An address that lands on a reply names
+   * its Thread, because translations link whole Threads.
+   *
+   * @param postId - Any Post in the Thread looking for a translation
+   * @param path - Internal path, as produced by `toInternalPath()`
+   * @returns The Thread root to link, or why it cannot be
+   * @example
+   * await posts.resolveTranslationCandidate(id, "/hello-world");
+   * // { status: "unpublished" }
+   */
+  resolveTranslationCandidate(
+    postId: string,
+    path: string,
+  ): Promise<TranslationCandidateResolution>;
+  /**
+   * Link two already-published Thread roots as translations of each other.
+   *
+   * Joins the side without a group into the other's group, minting one when
+   * neither has any. Merging two existing groups is refused — that would
+   * silently restructure both sides.
+   *
+   * @throws {ConflictError} When the languages clash or both sides have groups
+   */
+  linkTranslation(postId: string, otherPostId: string): Promise<void>;
+  /**
+   * Remove a Thread root from its translation group. When that leaves a single
+   * Post behind, its group is cleared too so no one-member groups survive.
+   */
+  unlinkTranslation(postId: string): Promise<void>;
   /** Get reply counts for multiple posts */
   getReplyCounts(postIds: string[]): Promise<Map<string, number>>;
   /** Get preview replies for multiple thread roots */
@@ -450,7 +696,10 @@ export interface PostService {
     collectionIds: string[],
     options?: CollectionFeedEntryOptions,
   ): Promise<CollectionFeedEntry[]>;
-  /** Fetch published Posts for each requested Thread root. */
+  /**
+   * Fetch published Posts for each requested Thread root, in Thread order: the
+   * root first, then replies by creation time, then ID.
+   */
   getPublishedThreads(
     rootIds: string[],
     options?: Pick<PostFilters, "publishedBefore">,
@@ -458,7 +707,8 @@ export interface PostService {
   /** Get distinct years with posts, bucketed on the `sortBy` time axis */
   getDistinctYears(filters?: PostFilters): Promise<number[]>;
   /**
-   * For each Thread ID, resolve the Post that currently ends the chain.
+   * For each Thread ID, resolve the Post that currently ends the chain: the
+   * last in Thread order, so the root only while it has no replies.
    *
    * Two callers need two different answers. Readers ask what the audience can
    * see, so drafts must not count — the Reply affordance belongs on the last
@@ -544,6 +794,9 @@ export async function rebuildPostBodyHtmlWithRuntimeSettings(
 
 const SLUG_RE = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
 
+const INVALID_POST_BODY_MESSAGE =
+  "The body isn't a TipTap JSON document. Send a doc node as a JSON string, or send Markdown as bodyMarkdown.";
+
 function isValidSlug(value: string): boolean {
   return SLUG_RE.test(value);
 }
@@ -619,6 +872,34 @@ function ensurePostRating(
   throw new ErrorCtor("Rating must be an integer between 1 and 5.");
 }
 
+/**
+ * Normalize a caller-supplied content language to what the column stores.
+ *
+ * Empty, missing, and unparseable values all become `null` — the single-language
+ * state — so the column never holds a half-set value. Whether the tag is one
+ * the site actually offers is a settings-layer question, checked where the site
+ * language configuration is in scope.
+ *
+ * @param value - Raw BCP 47 tag from a request or import
+ * @returns Canonical tag (`zh-Hans`), or `null` when there is nothing to store
+ * @example
+ * normalizePostLanguage("ZH-hans"); // "zh-Hans"
+ * normalizePostLanguage("  ");      // null
+ */
+export function normalizePostLanguage(
+  value: string | null | undefined,
+): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (!isValidContentLanguage(trimmed)) {
+    throw new ValidationError(
+      "Enter a valid BCP 47 language tag (e.g. en, zh-Hans, ja).",
+    );
+  }
+  return normalizeContentLanguage(trimmed);
+}
+
 function assertPostFormatShape(data: {
   format: Format;
   title?: string | null;
@@ -711,6 +992,33 @@ export function createPostService(
     return posts.publishedAt;
   }
 
+  /**
+   * Thread order: the root first, then replies by creation time, then ID.
+   *
+   * The root leads whatever its own `createdAt` says. A reply can be older
+   * than its root — a post moved into a Thread keeps its creation time, and an
+   * export without `created` dates every post by publication — and ordering
+   * on time alone would open such a Thread on a reply. Every surface that
+   * reads the first post as the root would then lose it: the Thread page's
+   * canonical URL, Featured, Collections, the feeds, and the reply guard's
+   * idea of where the Thread ends. Every query that orders a Thread's posts
+   * goes through here so they agree.
+   *
+   * @param direction - `desc` walks from the Thread's end back to its root
+   * @returns ORDER BY terms, placed after any partitioning column
+   * @example
+   * db.select().from(posts).orderBy(posts.threadId, ...threadOrder());
+   * sql`ROW_NUMBER() OVER (ORDER BY ${sql.join(threadOrder(), sql`, `)})`;
+   */
+  function threadOrder(direction: "asc" | "desc" = "asc"): SQL[] {
+    const terms = [
+      sql`CASE WHEN ${posts.replyToId} IS NULL THEN 0 ELSE 1 END`,
+      sql`${posts.createdAt}`,
+      sql`${posts.id}`,
+    ];
+    return direction === "asc" ? terms : terms.map((term) => desc(term));
+  }
+
   function buildYearMonthExpr(column: SQLWrapper): SQL<string> {
     return databaseDialect === "pg"
       ? sql<string>`to_char(timezone('UTC', to_timestamp(${column})), 'YYYY-MM')`
@@ -723,11 +1031,6 @@ export function createPostService(
       : sql<string>`strftime('%Y', ${column}, 'unixepoch')`;
   }
 
-  const effectiveVisibilityExpr = sql<string>`coalesce(
-    ${posts.visibility},
-    (SELECT root.visibility FROM post AS root WHERE root.id = ${posts.threadId} AND root.site_id = ${siteId})
-  )`;
-
   /** Check if a slug is available (not used by posts or path_registry) */
   async function isSlugAvailable(slug: string): Promise<boolean> {
     return resolvedPaths.isPathAvailable(slug);
@@ -934,22 +1237,71 @@ export function createPostService(
     )`;
   }
 
-  /** Build WHERE conditions from filters (shared by list and count) */
-  function buildFilterConditions(filters: PostFilters) {
-    const conditions = [eq(posts.siteId, siteId)];
-
-    if (filters.status) {
-      conditions.push(eq(posts.status, filters.status));
-    }
-    if (filters.visibility !== undefined) {
-      conditions.push(sql`${effectiveVisibilityExpr} = ${filters.visibility}`);
+  /**
+   * Load a Post and assert it can carry a translation group.
+   *
+   * Groups live on Thread roots only, and both sides must belong to this site.
+   * These two rules replace the table CHECK the SQLite schema cannot add, so
+   * every write path that touches `translation_group_id` goes through here.
+   */
+  async function requireTranslatableRoot(
+    postId: string,
+  ): Promise<typeof posts.$inferSelect> {
+    const rows = await db
+      .select()
+      .from(posts)
+      .where(and(eq(posts.siteId, siteId), eq(posts.id, postId)))
+      .limit(1);
+    const row = rows[0];
+    if (!row) {
+      throw new NotFoundError("Post");
     }
-    if (filters.excludeLatestHidden) {
-      conditions.push(sql`${effectiveVisibilityExpr} != 'latest_hidden'`);
+    if (row.threadId !== row.id) {
+      throw new ValidationError(
+        "Translations link whole threads. Use the thread's first post.",
+      );
     }
-    if (filters.excludePrivate) {
-      conditions.push(sql`${effectiveVisibilityExpr} != 'private'`);
+    return row;
+  }
+
+  /** Reject a language another Post in the same translation group already holds. */
+  async function assertTranslationLanguageFree(
+    groupId: string,
+    language: string,
+    excludePostId?: string,
+  ): Promise<void> {
+    const rows = await db
+      .select({ id: posts.id, title: posts.title })
+      .from(posts)
+      .where(
+        and(
+          eq(posts.siteId, siteId),
+          eq(posts.translationGroupId, groupId),
+          eq(posts.language, language),
+        ),
+      )
+      .limit(2);
+    const clash = rows.find((row) => row.id !== excludePostId);
+    if (clash) {
+      // The language's own name, not its tag: this message is shown to the
+      // author, and "简体中文" is what they picked in the menu — "zh-Hans" is
+      // an implementation detail they never chose.
+      const languageName = getOrBuildEntry(language).native;
+      throw new ConflictError(
+        clash.title
+          ? `"${clash.title}" is already the ${languageName} version in this translation group. Unlink it first, or pick another language.`
+          : `Another post is already the ${languageName} version in this translation group. Unlink it first, or pick another language.`,
+      );
     }
+  }
+
+  /** Build WHERE conditions from filters (shared by list and count) */
+  function buildFilterConditions(filters: PostFilters) {
+    const conditions = [
+      eq(posts.siteId, siteId),
+      ...buildReaderVisibilityConditions(posts, siteId, filters),
+    ];
+
     if (filters.pinned !== undefined) {
       conditions.push(
         filters.pinned
@@ -979,6 +1331,9 @@ export function createPostService(
     if (filters.threadId) {
       conditions.push(eq(posts.threadId, filters.threadId));
     }
+    if (filters.ids !== undefined) {
+      conditions.push(inArray(posts.id, filters.ids));
+    }
     if (filters.excludeReplies) {
       conditions.push(isNull(posts.replyToId));
     }
@@ -1150,80 +1505,61 @@ export function createPostService(
             ...keys,
           ];
 
-    if (filters.featured || filters.sortOrder === undefined) {
-      if (filters.featured) {
-        return buildLexicographicCursorCondition(
-          withPinnedSortKey([
-            {
-              direction: "desc",
-              expr: featuredPublishedSortExpr,
-              value: cursorFeaturedPublishedAt,
-            },
-            { direction: "desc", expr: posts.id, value: cursorPost.id },
-          ]),
-        );
-      }
-
+    if (filters.featured) {
       return buildLexicographicCursorCondition(
         withPinnedSortKey([
           {
             direction: "desc",
-            expr: sortTimestampSortExpr,
-            value: cursorSortTimestamp,
+            expr: featuredPublishedSortExpr,
+            value: cursorFeaturedPublishedAt,
           },
           { direction: "desc", expr: posts.id, value: cursorPost.id },
         ]),
       );
     }
 
-    if (filters.sortOrder === "oldest") {
-      return buildLexicographicCursorCondition(
-        withPinnedSortKey([
-          {
-            direction: "asc",
-            expr: sortTimestampSortExpr,
-            value: cursorSortTimestamp,
-          },
-          { direction: "asc", expr: posts.id, value: cursorPost.id },
-        ]),
-      );
-    }
-
-    if (filters.sortOrder === "rating_desc") {
-      return buildLexicographicCursorCondition(
-        withPinnedSortKey([
-          {
-            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 },
-        ]),
-      );
+    // One case per sort order, mirroring `list()` key for key.
+    switch (filters.sortOrder ?? "newest") {
+      case "oldest":
+        return buildLexicographicCursorCondition(
+          withPinnedSortKey([
+            {
+              direction: "asc",
+              expr: sortTimestampSortExpr,
+              value: cursorSortTimestamp,
+            },
+            { direction: "asc", expr: posts.id, value: cursorPost.id },
+          ]),
+        );
+      case "rating_desc":
+        return buildLexicographicCursorCondition(
+          withPinnedSortKey([
+            {
+              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 },
+          ]),
+        );
+      case "newest":
+        return buildLexicographicCursorCondition(
+          withPinnedSortKey([
+            {
+              direction: "desc",
+              expr: sortTimestampSortExpr,
+              value: cursorSortTimestamp,
+            },
+            { direction: "desc", expr: posts.id, value: cursorPost.id },
+          ]),
+        );
     }
-
-    return buildLexicographicCursorCondition(
-      withPinnedSortKey([
-        {
-          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(
@@ -1258,6 +1594,8 @@ export function createPostService(
       previewProvider: row.previewProvider,
       replyToId: row.replyToId,
       threadId: row.threadId,
+      language: row.language,
+      translationGroupId: row.translationGroupId,
       quietReply: row.quietReply,
       publishedAt: row.publishedAt,
       lastActivityAt: row.lastActivityAt ?? row.publishedAt ?? row.updatedAt,
@@ -1271,14 +1609,80 @@ export function createPostService(
     };
   }
 
+  /**
+   * Thread visibility the loaded rows already answer, plus the thread ids they
+   * do not.
+   *
+   * A reply's own `visibility` column is null — it inherits the root's — so a
+   * row only speaks for its thread when it *is* the root. List surfaces query
+   * thread roots exclusively (`excludeReplies`), so for them this covers every
+   * thread and the follow-up read never runs.
+   *
+   * Entries are set only for a non-null visibility, matching
+   * {@link getThreadVisibilityMap}: a root row with no visibility is treated as
+   * unreadable by both paths.
+   */
+  function seedThreadVisibility(rows: (typeof posts.$inferSelect)[]): {
+    known: Map<string, Visibility>;
+    missingThreadIds: string[];
+  } {
+    const known = new Map<string, Visibility>();
+    const covered = new Set<string>();
+    for (const row of rows) {
+      if (row.id !== row.threadId) continue;
+      covered.add(row.threadId);
+      if (row.visibility) {
+        known.set(row.threadId, ensurePostVisibility(row.visibility, Error));
+      }
+    }
+    const missingThreadIds = [
+      ...new Set(
+        rows
+          .map((row) => row.threadId)
+          .filter((threadId) => !covered.has(threadId)),
+      ),
+    ];
+    return { known, missingThreadIds };
+  }
+
+  /**
+   * Slug lookup and root-visibility lookup are independent, so they go out
+   * together rather than one after the other.
+   */
+  async function loadHydrationMaps(
+    rows: (typeof posts.$inferSelect)[],
+  ): Promise<{
+    slugMap: Map<string, string>;
+    visibilityMap: Map<string, Visibility>;
+  }> {
+    const { known, missingThreadIds } = seedThreadVisibility(rows);
+    const [slugMap, fetched] = await Promise.all([
+      resolvedPaths.getPostSlugMap(rows.map((row) => row.id)),
+      missingThreadIds.length > 0
+        ? getThreadVisibilityMap(missingThreadIds)
+        : Promise.resolve(new Map<string, Visibility>()),
+    ]);
+    for (const [threadId, visibility] of fetched) {
+      known.set(threadId, visibility);
+    }
+    return { slugMap, visibilityMap: known };
+  }
+
   async function hydratePost(
     row: typeof posts.$inferSelect | undefined,
+    knownSlug?: string,
   ): Promise<Post | null> {
     if (!row) return null;
-    const slug = await resolvedPaths.getPostSlug(row.id);
+    const { known, missingThreadIds } = seedThreadVisibility([row]);
+    const [slug, fetched] = await Promise.all([
+      knownSlug ?? resolvedPaths.getPostSlug(row.id),
+      missingThreadIds.length > 0
+        ? getThreadVisibilityMap(missingThreadIds)
+        : Promise.resolve(new Map<string, Visibility>()),
+    ]);
     if (!slug) return null;
-    const rootVisibilityMap = await getThreadVisibilityMap([row.threadId]);
-    const visibility = rootVisibilityMap.get(row.threadId) ?? row.visibility;
+    const visibility =
+      known.get(row.threadId) ?? fetched.get(row.threadId) ?? row.visibility;
     if (!visibility) return null;
     return toPost(row, slug, visibility);
   }
@@ -1287,17 +1691,11 @@ export function createPostService(
     rows: (typeof posts.$inferSelect)[],
   ): Promise<Post[]> {
     if (rows.length === 0) return [];
-    const slugMap = await resolvedPaths.getPostSlugMap(
-      rows.map((row) => row.id),
-    );
-    const rootVisibilityMap = await getThreadVisibilityMap(
-      rows.map((row) => row.threadId),
-    );
+    const { slugMap, visibilityMap } = await loadHydrationMaps(rows);
     return rows
       .map((row) => {
         const slug = slugMap.get(row.id);
-        const visibility =
-          rootVisibilityMap.get(row.threadId) ?? row.visibility;
+        const visibility = visibilityMap.get(row.threadId) ?? row.visibility;
         return slug && visibility ? toPost(row, slug, visibility) : null;
       })
       .filter((row): row is Post => row !== null);
@@ -1355,18 +1753,10 @@ export function createPostService(
   }
 
   function buildThreadRootPageConditions(options?: ThreadRootPageOptions) {
-    const conditions: SQL[] = [eq(posts.siteId, siteId)];
-    const status = options?.status;
-
-    if (status) {
-      conditions.push(eq(posts.status, status));
-    }
-    if (options?.excludePrivate) {
-      conditions.push(sql`${effectiveVisibilityExpr} != 'private'`);
-    }
-    if (options?.excludeLatestHidden) {
-      conditions.push(sql`${effectiveVisibilityExpr} != 'latest_hidden'`);
-    }
+    const conditions: SQL[] = [
+      eq(posts.siteId, siteId),
+      ...buildReaderVisibilityConditions(posts, siteId, options ?? {}),
+    ];
     if (options?.publishedBefore !== undefined) {
       conditions.push(
         sql`${posts.publishedAt} < ${options.publishedBefore}`,
@@ -1391,6 +1781,9 @@ export function createPostService(
     if (options?.hasRating) {
       conditions.push(isNotNull(posts.rating));
     }
+    if (options?.threadIds !== undefined) {
+      conditions.push(inArray(posts.threadId, options.threadIds));
+    }
 
     return conditions;
   }
@@ -1617,6 +2010,45 @@ export function createPostService(
       return hydratePost(result[0]);
     },
 
+    async getWithCanonicalAlias(postId) {
+      const rows = await db
+        .select({ post: posts, path: pathRegistry })
+        .from(posts)
+        .leftJoin(
+          pathRegistry,
+          and(
+            eq(pathRegistry.siteId, siteId),
+            eq(pathRegistry.postId, posts.id),
+          ),
+        )
+        .where(and(eq(posts.siteId, siteId), eq(posts.id, postId)))
+        .orderBy(asc(pathRegistry.createdAt), asc(pathRegistry.id));
+
+      const row = rows[0];
+      if (!row) return null;
+
+      let slug: string | null = null;
+      let canonicalAlias: string | null = null;
+      for (const { path } of rows) {
+        if (!path) continue;
+        if (path.kind === "slug") {
+          slug = path.path;
+          continue;
+        }
+        // Rows arrive oldest first, so the last `alias` seen is the newest —
+        // the one a slug URL redirects to. Ties within a second fall to the
+        // higher id rather than to whatever the storage engine returned first.
+        if (path.kind === "alias") canonicalAlias = `/${path.path}`;
+      }
+
+      // A Post with no slug row has no address, which is what `hydratePost`
+      // says by returning null for it.
+      if (!slug) return null;
+
+      const post = await hydratePost(row.post, slug);
+      return post ? { post, canonicalAlias } : null;
+    },
+
     async getBodyContent(id) {
       const post = await this.getById(id);
       if (!post) return null;
@@ -1636,7 +2068,14 @@ export function createPostService(
       if (!resolved || resolved.kind !== "slug" || !resolved.postId) {
         return null;
       }
-      return this.getById(resolved.postId);
+      const result = await db
+        .select()
+        .from(posts)
+        .where(and(eq(posts.siteId, siteId), eq(posts.id, resolved.postId)))
+        .limit(1);
+      // The registry row that answered is the slug, so hydration does not go
+      // back for it.
+      return hydratePost(result[0], resolved.path);
     },
 
     async suggestSlug(input) {
@@ -1698,36 +2137,39 @@ export function createPostService(
         .where(conditions.length > 0 ? and(...conditions) : undefined)
         .limit(filters.limit ?? 100);
 
-      let query =
-        filters.featured || filters.sortOrder === undefined
-          ? baseQuery.orderBy(
+      // A case per sort order, and no shared fallthrough. This was an if/else
+      // chain whose last branch was written for one order and silently caught
+      // another, so `newest` ordered by rating instead of by time wherever it
+      // was passed explicitly — a smart collection page, most visibly.
+      const buildOrderBy = (): SQL<unknown>[] => {
+        if (filters.featured) {
+          return [
+            ...pinnedOrder,
+            desc(featuredPublishedSortExpr),
+            desc(posts.id),
+          ];
+        }
+        switch (filters.sortOrder ?? "newest") {
+          case "oldest":
+            return [...pinnedOrder, asc(sortTimestampSortExpr), asc(posts.id)];
+          case "rating_desc":
+            return [
               ...pinnedOrder,
-              filters.featured
-                ? desc(featuredPublishedSortExpr)
-                : desc(sortTimestampSortExpr),
+              desc(ratingPresence),
+              desc(posts.rating),
+              desc(sortTimestampSortExpr),
               desc(posts.id),
-            )
-          : filters.sortOrder === "oldest"
-            ? baseQuery.orderBy(
-                ...pinnedOrder,
-                asc(sortTimestampSortExpr),
-                asc(posts.id),
-              )
-            : filters.sortOrder === "rating_desc"
-              ? baseQuery.orderBy(
-                  ...pinnedOrder,
-                  desc(ratingPresence),
-                  desc(posts.rating),
-                  desc(sortTimestampSortExpr),
-                  desc(posts.id),
-                )
-              : baseQuery.orderBy(
-                  ...pinnedOrder,
-                  desc(ratingPresence),
-                  asc(posts.rating),
-                  desc(sortTimestampSortExpr),
-                  desc(posts.id),
-                );
+            ];
+          case "newest":
+            return [
+              ...pinnedOrder,
+              desc(sortTimestampSortExpr),
+              desc(posts.id),
+            ];
+        }
+      };
+
+      let query = baseQuery.orderBy(...buildOrderBy());
 
       if (filters.offset !== undefined) {
         query = query.offset(filters.offset) as typeof query;
@@ -1774,6 +2216,8 @@ export function createPostService(
           id: posts.id,
           updatedAt: threadModifiedAt,
           featuredAt: posts.featuredAt,
+          language: posts.language,
+          translationGroupId: posts.translationGroupId,
         })
         .from(posts)
         .where(conditions.length > 0 ? and(...conditions) : undefined)
@@ -1799,6 +2243,8 @@ export function createPostService(
             alias,
             updatedAt: row.updatedAt,
             featuredAt: row.featuredAt,
+            language: row.language,
+            translationGroupId: row.translationGroupId,
           };
         })
         .filter((entry): entry is SitemapPostEntry => entry !== null);
@@ -1845,6 +2291,59 @@ export function createPostService(
       return result[0]?.count ?? 0;
     },
 
+    async aggregateMany(filters, base) {
+      if (filters.length === 0) return [];
+
+      const baseConditions = buildFilterConditions(base);
+      // The row is its own Thread root here — callers exclude replies — so the
+      // activity expression reads the columns in hand. No correlated subquery.
+      const activityAt = buildRootActivityExpr({
+        lastActivityAt: posts.lastActivityAt,
+        publishedAt: posts.publishedAt,
+        updatedAt: posts.updatedAt,
+      });
+      // A `SUM(CASE …)` and a `MAX(CASE …)` per filter, over one pass of the
+      // rows the base predicate already narrows to. The aliases are positional
+      // and generated here, so nothing a caller supplies reaches the SQL as an
+      // identifier.
+      const columns = Object.fromEntries(
+        filters.flatMap((filter, index) => {
+          const conditions = buildFilterConditions({ ...base, ...filter });
+          const predicate =
+            conditions.length > 0 ? and(...conditions) : sql`1 = 1`;
+          return [
+            [
+              `n${index}`,
+              sql<number>`CAST(SUM(CASE WHEN (${predicate}) THEN 1 ELSE 0 END) AS INTEGER)`,
+            ],
+            [
+              `a${index}`,
+              sql<
+                number | null
+              >`MAX(CASE WHEN (${predicate}) THEN ${activityAt} END)`,
+            ],
+          ];
+        }),
+      );
+
+      const rows = await db
+        .select(columns)
+        .from(posts)
+        .where(baseConditions.length > 0 ? and(...baseConditions) : undefined);
+
+      const row = rows[0] as Record<string, number | null> | undefined;
+      return filters.map((_, index) => {
+        const activity = row?.[`a${index}`];
+        return {
+          count: Number(row?.[`n${index}`] ?? 0),
+          recentActivityAt:
+            activity === null || activity === undefined
+              ? null
+              : Number(activity),
+        };
+      });
+    },
+
     async countUpTo(filters = {}, limit) {
       const normalizedLimit = Math.max(0, Math.trunc(limit));
       if (normalizedLimit === 0) {
@@ -1898,6 +2397,9 @@ export function createPostService(
       const preparedBody = trimmedBody
         ? tryPreparePostBodyHtml(id, trimmedBody)
         : null;
+      if (preparedBody && !preparedBody.ok) {
+        throw new ValidationError(INVALID_POST_BODY_MESSAGE);
+      }
       const body = preparedBody?.ok ? preparedBody.body : trimmedBody;
       const title = data.title?.trim() || null;
       const quoteText = data.quoteText?.trim() || null;
@@ -1937,6 +2439,11 @@ export function createPostService(
       let threadId = id;
       let status: Status = requestedStatus ?? "published";
       let visibility: Visibility | null = requestedVisibility ?? "public";
+      // Roots carry the requested language; replies overwrite this with the
+      // root's value below so a Thread never mixes languages.
+      let language = normalizePostLanguage(data.language);
+      let translationGroupId: string | null = null;
+      let sourceTranslationPostId: string | null = null;
 
       // Collapse the two-input (`flag` + `flagAt`) pair the DTO exposes
       // into the single timestamp form the DB column stores. Explicit
@@ -2001,6 +2508,10 @@ export function createPostService(
           status = root.status;
         }
         visibility = null;
+        // A reply is part of the root's Thread, so it is written in the
+        // Thread's language whatever the caller asked for. This is what keeps
+        // language filters correct on member-grained queries.
+        language = root?.language ?? parent.language ?? null;
 
         if (
           (data.collectionIds?.length ?? 0) > 0 ||
@@ -2012,6 +2523,54 @@ export function createPostService(
         }
       }
 
+      const { primary, languages, reservedPrefixes } =
+        await readLanguageSettings(db, siteId, databaseSchema);
+
+      // Nobody named a language, so read one out of the text. Every write path
+      // that bypasses compose — the API, the Telegram bot, MCP — lands here, so
+      // a multilingual site never accumulates unlabelled posts. An explicit
+      // choice is the author's and is left alone; replies already carry the
+      // Thread's language.
+      if (!data.replyToId && !language) {
+        language = suggestPostLanguage({
+          text: bodyText ?? title ?? quoteText,
+          languages,
+          primary,
+        });
+      }
+
+      // "Add a translation" carries only the source ID until the author
+      // submits; the group is minted here so abandoning the composer leaves
+      // nothing behind (no draft row, no slug, no single-member group).
+      if (data.translationOfId) {
+        if (data.replyToId) {
+          throw new ValidationError(
+            "Translations link whole threads. Add the translation from the thread's first post.",
+          );
+        }
+        const source = await requireTranslatableRoot(data.translationOfId);
+        if (!language) {
+          throw new ValidationError(
+            "Choose a language for this translation before saving it.",
+          );
+        }
+        if (source.language === language) {
+          throw new ConflictError(
+            "That post is already written in this language. Pick a different language for the translation.",
+          );
+        }
+        if (source.translationGroupId) {
+          await assertTranslationLanguageFree(
+            source.translationGroupId,
+            language,
+          );
+          translationGroupId = source.translationGroupId;
+        } else {
+          translationGroupId = createEntityId("translationGroup");
+          sourceTranslationPostId = source.id;
+        }
+      }
+
       // Featured surfaces only list published posts, so featuring a draft
       // writes a flag that does nothing and shows nowhere. Say so instead.
       if (status === "draft" && resolvedFeaturedAt !== null) {
@@ -2021,6 +2580,8 @@ export function createPostService(
       assertDraftPublishedAt(status, data.publishedAt);
       const publishedAt =
         status === "published" ? (data.publishedAt ?? timestamp) : null;
+      const createdAt = data.createdAt ?? timestamp;
+      const updatedAt = data.updatedAt ?? createdAt;
 
       // Resolve slug from slug, path, or title
       let slug: string;
@@ -2033,10 +2594,17 @@ export function createPostService(
       // readable slug can still set one explicitly.
       const titleForSlug =
         format === "quote" ? undefined : (title ?? undefined);
+      // Only a non-primary language earns a readable language suffix: the bare
+      // namespace belongs to the primary language, and a suffix shared by two
+      // same-language posts distinguishes nothing.
+      const languageSuffix =
+        language && language !== primary
+          ? toLanguagePrefix(language)
+          : undefined;
 
       if (data.path) {
         const normalized = normalizePath(data.path);
-        if (isReservedPath(normalized)) {
+        if (isReservedPath(normalized, reservedPrefixes)) {
           throw new ValidationError(
             `Path "${normalized}" is reserved and cannot be used`,
           );
@@ -2046,6 +2614,7 @@ export function createPostService(
           slug = await generatePostSlug({
             slug: normalized,
             idLength: config.slugIdLength,
+            reservedPrefixes,
             isAvailable: isSlugAvailable,
           });
         } else {
@@ -2055,6 +2624,8 @@ export function createPostService(
             slug: slugified || undefined,
             title: titleForSlug,
             idLength: config.slugIdLength,
+            languageSuffix,
+            reservedPrefixes,
             isAvailable: isSlugAvailable,
           });
           // Verify the alias path is available before proceeding
@@ -2068,6 +2639,8 @@ export function createPostService(
           slug: data.slug,
           title: titleForSlug,
           idLength: config.slugIdLength,
+          languageSuffix,
+          reservedPrefixes,
           isAvailable: isSlugAvailable,
         });
       }
@@ -2127,6 +2700,23 @@ export function createPostService(
         if (usesBatchWrites) {
           const writeQueries = [];
 
+          // Mint the group on the source Post in the same write as the
+          // translation itself, so a failure never leaves a one-member group.
+          if (sourceTranslationPostId && translationGroupId) {
+            writeQueries.push(
+              db
+                .update(posts)
+                .set({ translationGroupId, updatedAt: timestamp })
+                .where(
+                  and(
+                    eq(posts.siteId, siteId),
+                    eq(posts.id, sourceTranslationPostId),
+                    isNull(posts.translationGroupId),
+                  ),
+                ),
+            );
+          }
+
           writeQueries.push(
             db.insert(posts).values({
               id,
@@ -2147,12 +2737,14 @@ export function createPostService(
               rating,
               replyToId: data.replyToId ?? null,
               threadId,
+              language,
+              translationGroupId,
               quietReply: isQuietReply,
               publishedAt,
-              lastActivityAt: publishedAt ?? timestamp,
-              threadUpdatedAt: publishedAt ?? timestamp,
-              createdAt: timestamp,
-              updatedAt: timestamp,
+              lastActivityAt: publishedAt ?? updatedAt,
+              threadUpdatedAt: publishedAt ?? updatedAt,
+              createdAt,
+              updatedAt,
             }),
           );
 
@@ -2207,6 +2799,19 @@ export function createPostService(
           );
         } else {
           await db.transaction(async (tx) => {
+            if (sourceTranslationPostId && translationGroupId) {
+              await tx
+                .update(posts)
+                .set({ translationGroupId, updatedAt: timestamp })
+                .where(
+                  and(
+                    eq(posts.siteId, siteId),
+                    eq(posts.id, sourceTranslationPostId),
+                    isNull(posts.translationGroupId),
+                  ),
+                );
+            }
+
             await tx.insert(posts).values({
               id,
               siteId,
@@ -2226,12 +2831,14 @@ export function createPostService(
               rating,
               replyToId: data.replyToId ?? null,
               threadId,
+              language,
+              translationGroupId,
               quietReply: isQuietReply,
               publishedAt,
-              lastActivityAt: publishedAt ?? timestamp,
-              threadUpdatedAt: publishedAt ?? timestamp,
-              createdAt: timestamp,
-              updatedAt: timestamp,
+              lastActivityAt: publishedAt ?? updatedAt,
+              threadUpdatedAt: publishedAt ?? updatedAt,
+              createdAt,
+              updatedAt,
             });
 
             await tx.insert(pathRegistry).values({
@@ -2358,13 +2965,16 @@ export function createPostService(
         // A reply with no date of its own belongs to the root's moment, not to
         // whenever the request happened to run. Without this, backdating the
         // root leaves its replies stamped today and the thread reads as if it
-        // spanned years. Thread order is by `createdAt`/`id` (see the thread
-        // queries), so sharing one `publishedAt` cannot reorder anything.
+        // spanned years. Thread order is the root, then `createdAt`/`id` (see
+        // `threadOrder`), so sharing one `publishedAt` cannot reorder anything.
         const rootPublishedAt = created[0]?.publishedAt ?? undefined;
         const postData: CreatePost = {
           ...data,
           // Chain each post as a reply to the previous one (server-side chaining)
           replyToId: i === 0 ? data.replyToId : prevPost?.id,
+          // Translation groups and languages are Thread-level: the root carries
+          // them and every reply inherits, so later items must not restate them.
+          translationOfId: i === 0 ? data.translationOfId : undefined,
           quietReply: extendsExistingThreadQuietly ? true : data.quietReply,
           publishedAt:
             i === 0 ? data.publishedAt : (data.publishedAt ?? rootPublishedAt),
@@ -2397,6 +3007,17 @@ export function createPostService(
       const existing = await this.getById(id);
       if (!existing) return null;
 
+      // Thread-wide, so it cannot ride along on the single-row write below.
+      // Runs first: if the language is refused — the Thread's translation group
+      // already holds it — nothing else should have been written either.
+      if (
+        data.language &&
+        !existing.replyToId &&
+        data.language !== existing.language
+      ) {
+        await this.setThreadLanguage(id, data.language);
+      }
+
       const timestamp = now();
       const nextFormat =
         data.format !== undefined
@@ -2505,6 +3126,9 @@ export function createPostService(
         const preparedBody = normalizedBody
           ? tryPreparePostBodyHtml(existing.id, normalizedBody)
           : null;
+        if (preparedBody && !preparedBody.ok) {
+          throw new ValidationError(INVALID_POST_BODY_MESSAGE);
+        }
         updatedBody = preparedBody?.ok ? preparedBody.body : normalizedBody;
         updates.body = updatedBody;
         updates.bodyHtml = preparedBody?.ok
@@ -2761,8 +3385,7 @@ export function createPostService(
           ],
         );
         updateResult = results[updateIdx] as
-          | (typeof posts.$inferSelect)[]
-          | undefined;
+          (typeof posts.$inferSelect)[] | undefined;
       } else {
         await db.transaction(async (tx) => {
           if (needsCascade) {
@@ -3044,7 +3667,7 @@ export function createPostService(
         .select()
         .from(posts)
         .where(and(eq(posts.siteId, siteId), eq(posts.threadId, rootId)))
-        .orderBy(posts.createdAt, posts.id);
+        .orderBy(...threadOrder());
 
       return hydratePosts(rows);
     },
@@ -3154,6 +3777,397 @@ export function createPostService(
       await recalculateThreadActivity(rootId);
     },
 
+    async setThreadLanguage(postId, language) {
+      const normalized = normalizePostLanguage(language);
+      if (!normalized) {
+        throw new ValidationError("Choose a language for this post.");
+      }
+
+      // A language the site does not publish has no view, no feed and no
+      // switcher entry, so the post would simply vanish. Only checked once the
+      // site actually has a language set to belong to.
+      const { languages } = await readLanguageSettings(
+        db,
+        siteId,
+        databaseSchema,
+      );
+      if (
+        languages.length > 0 &&
+        !languages.some(
+          (tag) => toLanguagePrefix(tag) === toLanguagePrefix(normalized),
+        )
+      ) {
+        throw new ValidationError(
+          "This site does not publish that language. Add it in Settings → Language first.",
+        );
+      }
+
+      const rows = await db
+        .select({
+          threadId: posts.threadId,
+          id: posts.id,
+          translationGroupId: posts.translationGroupId,
+        })
+        .from(posts)
+        .where(and(eq(posts.siteId, siteId), eq(posts.id, postId)))
+        .limit(1);
+      const row = rows[0];
+      if (!row) {
+        throw new NotFoundError("Post");
+      }
+
+      // The group lives on the root, so a reply's Thread has to be resolved
+      // before the translation-group check can run.
+      const rootRows =
+        row.id === row.threadId
+          ? [row]
+          : await db
+              .select({
+                threadId: posts.threadId,
+                id: posts.id,
+                translationGroupId: posts.translationGroupId,
+              })
+              .from(posts)
+              .where(and(eq(posts.siteId, siteId), eq(posts.id, row.threadId)))
+              .limit(1);
+      const root = rootRows[0];
+      if (root?.translationGroupId) {
+        await assertTranslationLanguageFree(
+          root.translationGroupId,
+          normalized,
+          root.id,
+        );
+      }
+
+      const timestamp = now();
+      await db
+        .update(posts)
+        .set({ language: normalized, updatedAt: timestamp })
+        .where(and(eq(posts.siteId, siteId), eq(posts.threadId, row.threadId)));
+    },
+
+    async materializeMissingLanguage(language) {
+      const normalized = normalizePostLanguage(language);
+      if (!normalized) {
+        throw new ValidationError("Choose a primary language for this site.");
+      }
+
+      // Counted before the write rather than read back from it: the three
+      // supported drivers report affected rows differently, and the caller only
+      // needs the number for its confirmation copy.
+      const pending = await this.countMissingLanguage();
+      if (pending === 0) return 0;
+
+      await db
+        .update(posts)
+        .set({ language: normalized })
+        .where(and(eq(posts.siteId, siteId), isNull(posts.language)));
+      return pending;
+    },
+
+    async countMissingLanguage() {
+      const rows = await db
+        .select({ count: sql<number>`CAST(count(*) AS INTEGER)` })
+        .from(posts)
+        .where(and(eq(posts.siteId, siteId), isNull(posts.language)));
+      return Number(rows[0]?.count ?? 0);
+    },
+
+    async countByLanguage(language) {
+      const normalized = normalizePostLanguage(language);
+      if (!normalized) return 0;
+
+      const rows = await db
+        .select({ count: sql<number>`CAST(count(*) AS INTEGER)` })
+        .from(posts)
+        .where(and(eq(posts.siteId, siteId), eq(posts.language, normalized)));
+      return Number(rows[0]?.count ?? 0);
+    },
+
+    async listLanguagesInUse() {
+      const rows = await db
+        .select({
+          language: posts.language,
+          count: sql<number>`CAST(count(*) AS INTEGER)`,
+        })
+        .from(posts)
+        .where(and(eq(posts.siteId, siteId), isNotNull(posts.language)))
+        .groupBy(posts.language);
+      return rows
+        .filter((row): row is { language: string; count: number } =>
+          Boolean(row.language),
+        )
+        .map((row) => ({ language: row.language, count: Number(row.count) }));
+    },
+
+    async listTranslations(postId) {
+      const map = await this.getTranslationsMap([postId]);
+      return map.get(postId) ?? [];
+    },
+
+    async listTranslationCandidates(postId, options) {
+      const term = options.query.trim();
+      if (!term) return [];
+      const limit = options.limit ?? 8;
+
+      const source = await this.getById(postId);
+      if (!source) return [];
+      const root =
+        source.replyToId === null
+          ? source
+          : await this.getById(source.threadId);
+      if (!root?.language) return [];
+
+      // Languages this Thread's group already speaks for, its own included.
+      const taken = new Set([root.language]);
+      if (root.translationGroupId) {
+        for (const sibling of await this.listTranslations(root.id)) {
+          if (sibling.language) taken.add(sibling.language);
+        }
+      }
+
+      // Escaped with an explicit ESCAPE clause: the two dialects disagree on
+      // the default escape character (see `paths.findPathsUnderSegment`).
+      const like = `%${term.replace(/[\\%_]/g, "\\$&")}%`;
+      const conditions: SQL[] = [
+        eq(posts.siteId, siteId),
+        eq(posts.status, "published"),
+        // Thread roots only: a translation links whole Threads.
+        sql`${posts.id} = ${posts.threadId}`,
+        sql`${posts.id} != ${root.id}`,
+        isNotNull(posts.language),
+        notInArray(posts.language, [...taken]),
+        sql`(${posts.title} LIKE ${like} ESCAPE '\\' OR ${posts.bodyText} LIKE ${like} ESCAPE '\\')`,
+      ];
+
+      if (root.translationGroupId) {
+        // Both sides having a group would ask for a merge, which is refused.
+        conditions.push(isNull(posts.translationGroupId));
+      } else {
+        // The candidate may carry a group, as long as joining it would not put
+        // two Posts of this language in it.
+        conditions.push(
+          sql`(${posts.translationGroupId} IS NULL OR NOT EXISTS (
+            SELECT 1
+            FROM post AS group_member
+            WHERE group_member.site_id = ${siteId}
+              AND group_member.translation_group_id = "post"."translation_group_id"
+              AND group_member.language = ${root.language}
+          ))`,
+        );
+      }
+
+      const rows = await db
+        .select()
+        .from(posts)
+        .where(and(...conditions))
+        .orderBy(desc(posts.publishedAt))
+        .limit(limit);
+
+      return hydratePosts(rows);
+    },
+
+    async resolveTranslationCandidate(postId, path) {
+      const source = await this.getById(postId);
+      if (!source) return { status: "not_found" };
+      const root =
+        source.replyToId === null
+          ? source
+          : await this.getById(source.threadId);
+      if (!root?.language) return { status: "not_found" };
+
+      const target = await resolvedPaths.resolveTarget(path);
+      if (!target) return { status: "not_found" };
+      if (target.targetType !== "post" || !target.postId) {
+        return { status: "not_a_post" };
+      }
+
+      const found = await this.getById(target.postId);
+      if (!found) return { status: "not_found" };
+      // Translations link whole Threads, so an address that lands on a reply
+      // is taken as naming the Thread it belongs to.
+      const candidate =
+        found.replyToId === null ? found : await this.getById(found.threadId);
+      if (!candidate) return { status: "not_found" };
+
+      if (candidate.id === root.id) return { status: "same_thread" };
+      if (candidate.status !== "published") return { status: "unpublished" };
+      if (!candidate.language) return { status: "no_language" };
+      if (candidate.language === root.language) {
+        return { status: "same_language" };
+      }
+
+      const siblings = root.translationGroupId
+        ? await this.listTranslations(root.id)
+        : [];
+      if (siblings.some((post) => post.language === candidate.language)) {
+        return { status: "language_taken", language: candidate.language };
+      }
+
+      if (candidate.translationGroupId) {
+        // `linkTranslation` refuses to merge two groups, and refuses to join
+        // one that already speaks for this Thread's language.
+        if (root.translationGroupId) return { status: "group_conflict" };
+
+        const theirGroup = await this.listTranslations(candidate.id);
+        if (theirGroup.some((post) => post.language === root.language)) {
+          return { status: "group_language_taken", language: root.language };
+        }
+      }
+
+      return { status: "ok", post: candidate };
+    },
+
+    async getTranslationsMap(postIds) {
+      const result = new Map<string, Post[]>();
+      const uniqueIds = [...new Set(postIds)].filter(Boolean);
+      if (uniqueIds.length === 0) return result;
+
+      const seedRows = await db
+        .select({ id: posts.id, translationGroupId: posts.translationGroupId })
+        .from(posts)
+        .where(
+          and(
+            eq(posts.siteId, siteId),
+            inArray(posts.id, uniqueIds),
+            isNotNull(posts.translationGroupId),
+          ),
+        );
+      if (seedRows.length === 0) return result;
+
+      const groupIds = [
+        ...new Set(
+          seedRows
+            .map((row) => row.translationGroupId)
+            .filter((groupId): groupId is string => groupId !== null),
+        ),
+      ];
+      const memberRows = await db
+        .select()
+        .from(posts)
+        .where(
+          and(
+            eq(posts.siteId, siteId),
+            inArray(posts.translationGroupId, groupIds),
+          ),
+        );
+      const members = await hydratePosts(memberRows);
+      const byGroup = new Map<string, Post[]>();
+      for (const member of members) {
+        const groupId = member.translationGroupId;
+        if (!groupId) continue;
+        const bucket = byGroup.get(groupId);
+        if (bucket) bucket.push(member);
+        else byGroup.set(groupId, [member]);
+      }
+
+      for (const seed of seedRows) {
+        const groupId = seed.translationGroupId;
+        if (!groupId) continue;
+        const siblings = (byGroup.get(groupId) ?? []).filter(
+          (member) => member.id !== seed.id,
+        );
+        if (siblings.length > 0) result.set(seed.id, siblings);
+      }
+      return result;
+    },
+
+    async linkTranslation(postId, otherPostId) {
+      if (postId === otherPostId) {
+        throw new ValidationError("Pick a different post to link.");
+      }
+
+      const [post, other] = await Promise.all([
+        requireTranslatableRoot(postId),
+        requireTranslatableRoot(otherPostId),
+      ]);
+
+      if (!post.language || !other.language) {
+        throw new ValidationError(
+          "Both posts need a language before they can be linked as translations.",
+        );
+      }
+      if (post.language === other.language) {
+        throw new ConflictError(
+          "These two posts are written in the same language. Translations need different languages.",
+        );
+      }
+      if (post.translationGroupId && other.translationGroupId) {
+        if (post.translationGroupId === other.translationGroupId) return;
+        throw new ConflictError(
+          "Both posts already belong to translation groups. Unlink one of them first.",
+        );
+      }
+
+      const timestamp = now();
+      if (post.translationGroupId ?? other.translationGroupId) {
+        const groupId = (post.translationGroupId ??
+          other.translationGroupId) as string;
+        const joiningId = post.translationGroupId ? other.id : post.id;
+        const joiningLanguage = post.translationGroupId
+          ? other.language
+          : post.language;
+        await assertTranslationLanguageFree(groupId, joiningLanguage);
+        await db
+          .update(posts)
+          .set({ translationGroupId: groupId, updatedAt: timestamp })
+          .where(and(eq(posts.siteId, siteId), eq(posts.id, joiningId)));
+        return;
+      }
+
+      const groupId = createEntityId("translationGroup");
+      const setGroup = (targetId: string) =>
+        db
+          .update(posts)
+          .set({ translationGroupId: groupId, updatedAt: timestamp })
+          .where(and(eq(posts.siteId, siteId), eq(posts.id, targetId)));
+
+      if (usesBatchWrites) {
+        await db.batch([setGroup(post.id), setGroup(other.id)]);
+      } else {
+        await db.transaction(async (tx) => {
+          await tx
+            .update(posts)
+            .set({ translationGroupId: groupId, updatedAt: timestamp })
+            .where(and(eq(posts.siteId, siteId), eq(posts.id, post.id)));
+          await tx
+            .update(posts)
+            .set({ translationGroupId: groupId, updatedAt: timestamp })
+            .where(and(eq(posts.siteId, siteId), eq(posts.id, other.id)));
+        });
+      }
+    },
+
+    async unlinkTranslation(postId) {
+      const post = await requireTranslatableRoot(postId);
+      const groupId = post.translationGroupId;
+      if (!groupId) return;
+
+      const timestamp = now();
+      await db
+        .update(posts)
+        .set({ translationGroupId: null, updatedAt: timestamp })
+        .where(and(eq(posts.siteId, siteId), eq(posts.id, post.id)));
+
+      // A group of one is indistinguishable from no group and would linger as
+      // a dangling key, so collapse it as soon as the second-to-last member
+      // leaves.
+      const remaining = await db
+        .select({ id: posts.id })
+        .from(posts)
+        .where(
+          and(eq(posts.siteId, siteId), eq(posts.translationGroupId, groupId)),
+        )
+        .limit(2);
+      const lastMember = remaining.length === 1 ? remaining[0] : undefined;
+      if (lastMember) {
+        await db
+          .update(posts)
+          .set({ translationGroupId: null, updatedAt: timestamp })
+          .where(and(eq(posts.siteId, siteId), eq(posts.id, lastMember.id)));
+      }
+    },
+
     async getReplyCounts(postIds) {
       if (postIds.length === 0) return new Map();
 
@@ -3187,10 +4201,9 @@ export function createPostService(
         .select({
           id: posts.id,
           threadId: posts.threadId,
-          createdAt: posts.createdAt,
           previewRank: sql<number>`CAST(ROW_NUMBER() OVER (
             PARTITION BY ${posts.threadId}
-            ORDER BY ${posts.createdAt}, ${posts.id}
+            ORDER BY ${sql.join(threadOrder(), sql`, `)}
           ) AS INTEGER)`.as("preview_rank"),
         })
         .from(posts)
@@ -3208,15 +4221,10 @@ export function createPostService(
         .select({
           id: rankedReplies.id,
           threadId: rankedReplies.threadId,
-          createdAt: rankedReplies.createdAt,
         })
         .from(rankedReplies)
         .where(lte(rankedReplies.previewRank, previewCount))
-        .orderBy(
-          rankedReplies.threadId,
-          rankedReplies.createdAt,
-          rankedReplies.id,
-        );
+        .orderBy(rankedReplies.threadId, sql`${rankedReplies.previewRank}`);
 
       const hydratedPosts = await hydratePostsById(
         rankedRows.map((row) => row.id),
@@ -3246,11 +4254,11 @@ export function createPostService(
           threadId: posts.threadId,
           firstReplyRank: sql<number>`CAST(ROW_NUMBER() OVER (
             PARTITION BY ${posts.threadId}
-            ORDER BY ${posts.createdAt}, ${posts.id}
+            ORDER BY ${sql.join(threadOrder(), sql`, `)}
           ) AS INTEGER)`.as("first_reply_rank"),
           latestReplyRank: sql<number>`CAST(ROW_NUMBER() OVER (
             PARTITION BY ${posts.threadId}
-            ORDER BY ${posts.createdAt} DESC, ${posts.id} DESC
+            ORDER BY ${sql.join(threadOrder("desc"), sql`, `)}
           ) AS INTEGER)`.as("latest_reply_rank"),
           totalReplyCount: sql<number>`CAST(COUNT(*) OVER (
             PARTITION BY ${posts.threadId}
@@ -3278,8 +4286,11 @@ export function createPostService(
         .from(rankedReplies)
         .where(
           or(
-            lte(rankedReplies.firstReplyRank, 2),
-            lte(rankedReplies.latestReplyRank, 3),
+            // One past the leading window: that extra row is never rendered,
+            // it is only where the gap link points. Without it the gap has to
+            // aim at a reply already on screen.
+            lte(rankedReplies.firstReplyRank, THREAD_LEADING_REPLIES + 1),
+            lte(rankedReplies.latestReplyRank, THREAD_TRAILING_REPLIES),
           ),
         );
 
@@ -3293,6 +4304,7 @@ export function createPostService(
           leadingReplyIds: Map<number, string>;
           trailingReplyIds: Map<number, string>;
           latestReplyId: string | null;
+          firstHiddenReplyId: string | null;
           totalReplyCount: number;
         }
       >();
@@ -3301,13 +4313,20 @@ export function createPostService(
           leadingReplyIds: new Map<number, string>(),
           trailingReplyIds: new Map<number, string>(),
           latestReplyId: null,
+          firstHiddenReplyId: null,
           totalReplyCount: row.totalReplyCount,
         };
 
-        if (row.firstReplyRank <= 2) {
+        if (row.firstReplyRank <= THREAD_LEADING_REPLIES) {
           existing.leadingReplyIds.set(row.firstReplyRank, row.id);
         }
-        if (row.latestReplyRank === 2 || row.latestReplyRank === 3) {
+        if (row.firstReplyRank === THREAD_LEADING_REPLIES + 1) {
+          existing.firstHiddenReplyId = row.id;
+        }
+        if (
+          row.latestReplyRank > 1 &&
+          row.latestReplyRank <= THREAD_TRAILING_REPLIES
+        ) {
           existing.trailingReplyIds.set(row.latestReplyRank, row.id);
         }
         if (row.latestReplyRank === 1) {
@@ -3329,16 +4348,36 @@ export function createPostService(
             .map((id) => (id ? hydratedPosts.get(id) : undefined))
             .filter((post): post is Post => post !== undefined);
 
+        const leadingReplies = hydrateReplyIds(
+          Array.from({ length: THREAD_LEADING_REPLIES }, (_unused, index) =>
+            context.leadingReplyIds.get(index + 1),
+          ),
+        );
+        // Ranked newest-first, so walking down to rank 2 puts them back in
+        // thread order. Rank 1 is the hero and is carried separately.
+        const trailingReplies = hydrateReplyIds(
+          Array.from(
+            { length: THREAD_TRAILING_REPLIES - 1 },
+            (_unused, index) =>
+              context.trailingReplyIds.get(THREAD_TRAILING_REPLIES - index),
+          ),
+        );
+        const firstHiddenReply =
+          (context.firstHiddenReplyId
+            ? hydratedPosts.get(context.firstHiddenReplyId)
+            : undefined) ?? null;
+
         result.set(threadId, {
-          leadingReplies: hydrateReplyIds([
-            context.leadingReplyIds.get(1),
-            context.leadingReplyIds.get(2),
-          ]),
-          trailingReplies: hydrateReplyIds([
-            context.trailingReplyIds.get(3),
-            context.trailingReplyIds.get(2),
-          ]),
+          leadingReplies,
+          // Left overlapping on purpose. These are the ranked buckets, not the
+          // rendered fold: on a short thread a reply lands in both windows, and
+          // dropping the duplicate is a presentation rule that `ThreadPreview`
+          // and `getThreadHiddenCount` each already apply.
+          trailingReplies,
           latestReply,
+          // Only a gap target: the query fetches it one past the leading
+          // window, and nothing renders it.
+          firstHiddenReply,
           totalReplyCount: context.totalReplyCount,
         });
       }
@@ -3404,7 +4443,7 @@ export function createPostService(
       const threadPosition = sql<number>`CAST(
         row_number() OVER (
           PARTITION BY ${posts.threadId}
-          ORDER BY ${posts.createdAt}, ${posts.id}
+          ORDER BY ${sql.join(threadOrder(), sql`, `)}
         ) - 1 AS INTEGER
       )`.as("thread_position");
       const threadPostCount = sql<number>`CAST(
@@ -3728,20 +4767,25 @@ export function createPostService(
       const result = new Map<string, Post[]>();
       if (rootIds.length === 0) return result;
 
-      const unique = [...new Set(rootIds)];
-      const conditions = [
-        eq(posts.siteId, siteId),
-        inArray(posts.threadId, unique),
-        eq(posts.status, "published"),
-      ];
-      if (options.publishedBefore !== undefined) {
-        conditions.push(sql`${posts.publishedAt} < ${options.publishedBefore}`);
-      }
-      const rows = await db
-        .select()
-        .from(posts)
-        .where(and(...conditions))
-        .orderBy(posts.threadId, posts.createdAt, posts.id);
+      // A feed loads every Thread it renders at once, which can be hundreds.
+      // Each Thread lands in one chunk, so its posts keep their order.
+      const rows = await batchQueryRows([...new Set(rootIds)], (chunk) => {
+        const conditions = [
+          eq(posts.siteId, siteId),
+          inArray(posts.threadId, chunk),
+          eq(posts.status, "published"),
+        ];
+        if (options.publishedBefore !== undefined) {
+          conditions.push(
+            sql`${posts.publishedAt} < ${options.publishedBefore}`,
+          );
+        }
+        return db
+          .select()
+          .from(posts)
+          .where(and(...conditions))
+          .orderBy(posts.threadId, ...threadOrder());
+      });
 
       for (const post of await hydratePosts(rows)) {
         const thread = result.get(post.threadId);
@@ -3773,7 +4817,7 @@ export function createPostService(
             ...(options?.includeDrafts ? [] : [eq(posts.status, "published")]),
           ),
         )
-        .orderBy(posts.threadId, desc(posts.createdAt), desc(posts.id));
+        .orderBy(posts.threadId, ...threadOrder("desc"));
 
       for (const row of rows) {
         if (!result.has(row.threadId)) {