@jant/core 0.6.15 → 0.7.0

package/src/lib/slugify.ts

@@ -0,0 +1,113 @@
+/**
+ * Slug generation from free text.
+ *
+ * Lives apart from `url.ts` on purpose: `limax` drags the whole `pinyin-pro`
+ * dictionary (≈390 KB minified) into any bundle that imports it. Keeping the
+ * dictionary behind this single module lets the browser load it lazily via
+ * `client/lazy-slugify.ts`, while `url.ts` stays cheap enough for the public
+ * bundle. The build guard in `vite.shared.ts` fails the client build if
+ * `pinyin-pro` ever lands in an entry chunk again.
+ */
+
+import limax from "limax";
+
+import {
+  HAN_RE,
+  HANGUL_RE,
+  KANA_RE,
+  hangulToLatin,
+  kanaToRomaji,
+} from "./translit.js";
+
+const HAN_GLOBAL_RE = /\p{Script=Han}/gu;
+const CONTENT_CHAR_RE = /[\p{L}\p{N}]/u;
+const ASCII_ALNUM_RE = /[a-zA-Z0-9]/;
+
+/**
+ * Minimum fraction of a title's letters/digits the transliteration pipeline
+ * must handle for the result to be usable. Below this, too much meaning is
+ * lost (e.g. mixed kanji+kana Japanese where the semantic core is kanji, or
+ * scripts limax drops entirely) and `slugify` returns "" so callers fall back
+ * to their random-ID path instead of shipping a garbled slug.
+ */
+const SLUG_COVERAGE_THRESHOLD = 0.75;
+
+/** Per-character limax probe cache: does this char transliterate to anything? */
+const charCoverageCache = new Map<string, boolean>();
+
+function isCharCovered(char: string): boolean {
+  if (ASCII_ALNUM_RE.test(char)) return true;
+  let covered = charCoverageCache.get(char);
+  if (covered === undefined) {
+    covered = limax(char, { tone: false }).length > 0;
+    charCoverageCache.set(char, covered);
+  }
+  return covered;
+}
+
+function slugCoverage(text: string, japanese: boolean): number {
+  let content = 0;
+  let covered = 0;
+  for (const char of text) {
+    if (!CONTENT_CHAR_RE.test(char)) continue;
+    content++;
+    if (KANA_RE.test(char) || HANGUL_RE.test(char)) {
+      covered++;
+    } else if (japanese && HAN_RE.test(char)) {
+      // Kanji in a kana-containing title is dropped, never pinyin-read.
+    } else if (isCharCovered(char)) {
+      covered++;
+    }
+  }
+  return content === 0 ? 0 : covered / content;
+}
+
+/**
+ * Converts text to a URL-friendly slug.
+ *
+ * Transliterates i18n text to Latin before slugifying: Korean hangul via
+ * Revised Romanization, Japanese kana via Hepburn romaji (both in-house, see
+ * `translit.ts`), everything else (Han → pinyin, Cyrillic, accents, …) via
+ * limax. When the title contains kana it is treated as Japanese and Han
+ * characters are dropped rather than misread as Chinese pinyin; Han without
+ * kana is treated as Chinese.
+ *
+ * Returns `""` when transliteration would lose too much of the title (see
+ * `SLUG_COVERAGE_THRESHOLD`) — every caller treats an empty base as "no
+ * usable title" and falls back to a random ID, which beats publishing a
+ * garbled slug.
+ *
+ * @param text - The text to convert to a slug
+ * @returns The slugified string, or `""` when no usable slug can be derived
+ *
+ * @example
+ * ```ts
+ * slugify("Hello World! This is a Test.");
+ * // Returns: "hello-world-this-is-a-test"
+ *
+ * slugify("书评");
+ * // Returns: "shu-ping"
+ *
+ * slugify("안녕하세요 세계");
+ * // Returns: "annyeonghaseyo-segye"
+ *
+ * slugify("ハンバーガー");
+ * // Returns: "hanbaga"
+ *
+ * slugify("日本語のタイトルです");
+ * // Returns: "" (kanji carries the meaning and can't be transliterated)
+ * ```
+ */
+export function slugify(text: string): string {
+  const japanese = KANA_RE.test(text);
+  let pre = text;
+  if (japanese) {
+    pre = kanaToRomaji(pre.replace(HAN_GLOBAL_RE, " "));
+  }
+  if (HANGUL_RE.test(pre)) {
+    pre = hangulToLatin(pre);
+  }
+  const base = limax(pre, { tone: false }).replace(/_/g, "-");
+  if (!base) return "";
+  return slugCoverage(text, japanese) >= SLUG_COVERAGE_THRESHOLD ? base : "";
+}

package/src/lib/startup-config.ts

@@ -1,4 +1,5 @@
 import { escapeHtml } from "./html.js";
+import { getJantDocsUrl } from "./jant-docs.js";
 import {
   getAuthSecret,
   getHostedControlPlaneBaseUrl,
@@ -94,8 +95,7 @@ function getAuthSecretErrorHtml(kind: AuthSecretIssueKind): string {
   return renderConfigurationErrorPage({
     title: titleByKind[kind],
     bodyHtml: `${leadByKind[kind]}${runtimeInstructions}`,
-    docsHref:
-      "https://github.com/jant-me/jant/blob/main/docs/configuration.md#required",
+    docsHref: getJantDocsUrl("configuration#required"),
   });
 }
 
@@ -219,8 +219,7 @@ function getHostBasedConfigurationErrorHtml(
   return renderConfigurationErrorPage({
     title: "Hosted configuration is incomplete",
     bodyHtml: `<p>Jant is running with <code>SITE_RESOLUTION_MODE=host-based</code>, so hosted control-plane integration must be configured before the instance can serve requests.</p><ul>${itemsHtml}</ul>`,
-    docsHref:
-      "https://github.com/jant-me/jant/blob/main/docs/configuration.md#hosted-control-plane-integration-variables",
+    docsHref: getJantDocsUrl("configuration"),
   });
 }
 
@@ -243,8 +242,7 @@ export function getRuntimeConfigurationErrorPage(message: string): string {
   return renderConfigurationErrorPage({
     title: "Configuration Error",
     bodyHtml: `<p>${escapeHtml(message)}</p><p>Update your environment or instance data, then restart Jant.</p>`,
-    docsHref:
-      "https://github.com/jant-me/jant/blob/main/docs/configuration.md#site-resolution",
+    docsHref: getJantDocsUrl("configuration"),
   });
 }
 

package/src/lib/storage.ts

@@ -432,6 +432,13 @@ export function createS3Driver(config: S3DriverConfig): StorageDriver {
           // uploaded object checksums during finalize, so only enable response
           // checksum verification when a request explicitly asks for it.
           responseChecksumValidation: "WHEN_REQUIRED",
+          // Presigning runs with an empty body, so the SDK's default
+          // "WHEN_SUPPORTED" request checksums bake CRC32-of-nothing
+          // (x-amz-checksum-crc32=AAAAAA==) into every presigned PUT URL. The
+          // browser then uploads real bytes and the storage provider rejects
+          // the mismatch. Only send a request checksum when the caller asked
+          // for one (presignPut passes ChecksumSHA256 explicitly).
+          requestChecksumCalculation: "WHEN_REQUIRED",
         });
         return {
           send: (cmd: unknown) => client.send(cmd as never),

package/src/lib/summary.ts

@@ -22,6 +22,21 @@ interface TiptapNode {
   attrs?: Record<string, unknown>;
 }
 
+/**
+ * Summary limits for titled, article-style posts — the excerpt is a teaser
+ * and the reader continues on the post's own page.
+ */
+export const ARTICLE_SUMMARY_MAX_BLOCKS = 5;
+export const ARTICLE_SUMMARY_MAX_CHARS = 500;
+/**
+ * Larger limits for untitled notes — the body itself is the content, so the
+ * preview only exists to cap runaway length.
+ */
+export const NOTE_SUMMARY_MAX_BLOCKS = 10;
+export const NOTE_SUMMARY_MAX_CHARS = 1500;
+/** Don't truncate an untitled note just to hide a tail under this many chars. */
+export const NOTE_SUMMARY_MIN_HIDDEN_CHARS = 200;
+
 /**
  * Block node types that carry user-visible content for summary extraction.
  * Structural nodes (horizontalRule, moreBreak, image) are excluded.
@@ -348,3 +363,38 @@ export function extractSummaryHtml(
     breakAtIndex: lastSelectedIdx + 1,
   };
 }
+
+/**
+ * Extract the summary the site's timeline shows for a post, at the boundary
+ * the timeline uses.
+ *
+ * Wraps {@link extractSummaryHtml} with the limits that decide where a card
+ * stops: a titled post is an article whose excerpt is a teaser, an untitled one
+ * is a note whose body is the content and only needs a cap. Callers that need
+ * that boundary — the feed renderer, the theme exporter — share this rather
+ * than repeating five numbers each.
+ *
+ * @param bodyJson - TipTap JSON body, or null/undefined for a post without one
+ * @param hasTitle - Whether the post has a title, which makes it an article
+ * @param renderOptions - Renderer options, notably the footnote namespace
+ * @returns The truncated HTML and whether content continues, or null when
+ *   there is no TipTap document to truncate
+ * @example
+ * extractTimelineSummary(post.body, !!post.title, { namespace: post.id });
+ * // { html: "<p>Intro</p>", hasMore: true }
+ */
+export function extractTimelineSummary(
+  bodyJson: string | null | undefined,
+  hasTitle: boolean,
+  renderOptions: TiptapRenderOptions = {},
+): { html: string; hasMore: boolean } | null {
+  if (!bodyJson) return null;
+  const result = extractSummaryHtml(
+    bodyJson,
+    hasTitle ? ARTICLE_SUMMARY_MAX_BLOCKS : NOTE_SUMMARY_MAX_BLOCKS,
+    hasTitle ? ARTICLE_SUMMARY_MAX_CHARS : NOTE_SUMMARY_MAX_CHARS,
+    hasTitle ? 0 : NOTE_SUMMARY_MIN_HIDDEN_CHARS,
+    renderOptions,
+  );
+  return result ? { html: result.html, hasMore: result.hasMore } : null;
+}

package/src/lib/thread-fold.ts

@@ -0,0 +1,161 @@
+/**
+ * Thread Fold
+ *
+ * How much of a thread the timeline shows, and how much it folds away.
+ *
+ * A thread appears in two places that cannot select its posts the same way.
+ * The site paints a page of timeline items and must not load whole threads to
+ * do it, so `getThreadTimelineContext` ranks replies in SQL and hands the
+ * buckets down. The feed already holds every reply — `<content>` carries the
+ * whole chain — so it slices the array it has. Two access paths, one rule.
+ *
+ * This module owns what they share: the thresholds, and the arithmetic that
+ * turns a selection into a hidden count. Whoever changes the shape of the fold
+ * changes it here, and both surfaces move together.
+ *
+ * ## The fold
+ *
+ * ```
+ * root · reply 1 · reply 2 · [N more posts] · 3rd-newest · 2nd-newest · newest
+ * ```
+ *
+ * Six posts at most. A thread that fits arrives whole, with no gap at all —
+ * the gap appears only once something is actually left out.
+ *
+ * ## Where the gap points
+ *
+ * **At the first post it hides.** The link stands for a run of posts, and it
+ * opens the earliest of them, so a reader following "3 more posts" lands on
+ * the first of those three.
+ *
+ * It used to open the last *visible* post instead, on the reasoning that the
+ * detail page would then start just above the missing stretch, like a
+ * bookmark. That was a deliberate choice and it reads well on the site — but
+ * it makes the link mean something other than what its label says, and the
+ * feed cannot follow it: `<jant:thread>`'s `gap` attribute is documented as
+ * the first hidden post, and a consumer joining it against the `<jant:post>`
+ * rows would be handed a post that is on screen. One rule beats two, so both
+ * surfaces open the first hidden post.
+ */
+
+import type { Post, PostView } from "../types.js";
+
+/**
+ * Replies kept from the start of a thread, as context for the newest post.
+ *
+ * Also fixes where the SQL path's rank cut-off falls, so the two selections
+ * stay the same fold.
+ */
+export const THREAD_LEADING_REPLIES = 2;
+
+/**
+ * Replies kept from the end of a thread, the newest one included — it is the
+ * hero, and the two before it are its immediate context.
+ */
+export const THREAD_TRAILING_REPLIES = 3;
+
+/** Anything with an id, which is all the dedupe needs. */
+type Identified = Pick<Post, "id"> | Pick<PostView, "id">;
+
+/**
+ * How many replies a fold leaves unshown.
+ *
+ * Deduplicated, because on a short thread the buckets overlap: with four
+ * replies the first is also the third-newest, and counting it twice would
+ * report posts hidden that are on screen.
+ *
+ * @param selection - The replies the fold shows, and the thread's total
+ * @returns Replies the fold hides, never negative
+ * @example
+ * getThreadHiddenCount({ leadingReplies: [r1, r2], trailingReplies: [r6, r7],
+ *   latestReply: r8, totalReplyCount: 8 }); // 3
+ */
+export function getThreadHiddenCount({
+  leadingReplies,
+  trailingReplies,
+  latestReply,
+  totalReplyCount,
+}: {
+  leadingReplies: Identified[];
+  trailingReplies: Identified[];
+  latestReply: Identified;
+  totalReplyCount: number;
+}): number {
+  const shown = new Set(
+    [...leadingReplies, ...trailingReplies, latestReply].map((post) => post.id),
+  );
+  return Math.max(0, totalReplyCount - shown.size);
+}
+
+/** What the fold shows of a thread, and what it hides. */
+export interface ThreadFold<T> {
+  /** Earliest replies, kept as context above the gap. */
+  leadingReplies: T[];
+  /** Replies just before the newest, kept as its immediate context. */
+  trailingReplies: T[];
+  /** The newest reply — the hero the timeline builds the card around. */
+  latestReply: T;
+  /** First reply the fold hides, which is where the gap link points. */
+  firstHiddenReply: T | null;
+  /** How many replies the fold hides. */
+  hiddenCount: number;
+}
+
+/**
+ * Fold a thread whose replies are already in hand.
+ *
+ * Takes the same slices the SQL path ranks for: the first
+ * `THREAD_LEADING_REPLIES`, and the last `THREAD_TRAILING_REPLIES` with the
+ * newest as the hero. `getPublishedThreads` orders replies by
+ * `(threadId, createdAt, id)` ascending, which is the window function's own
+ * `ORDER BY`, so position in this array *is* the rank — no approximation.
+ *
+ * @param replies - Every published reply, oldest first
+ * @returns The fold, or null when the thread has no replies
+ * @example
+ * foldThreadReplies([r1, r2, r3, r4, r5, r6, r7, r8]);
+ * // leading [r1, r2], trailing [r6, r7], latest r8, firstHidden r3, hidden 3
+ */
+export function foldThreadReplies<T extends Identified>(
+  replies: T[],
+): ThreadFold<T> | null {
+  const latestReply = replies.at(-1);
+  if (!latestReply) return null;
+
+  // A short thread's windows overlap, and the hero is inside both of them on
+  // the shortest ones: with a single reply, that reply is the newest *and* the
+  // whole leading window. Each list therefore drops whatever an earlier one
+  // already shows, hero first — the same order `ThreadPreview` dedupes in when
+  // it walks the buckets the SQL path hands it.
+  const leadingReplies = replies
+    .slice(0, THREAD_LEADING_REPLIES)
+    .filter((reply) => reply.id !== latestReply.id);
+
+  const leadingIds = new Set(leadingReplies.map((reply) => reply.id));
+  const trailingReplies = replies
+    .slice(-THREAD_TRAILING_REPLIES, -1)
+    .filter(
+      (reply) => reply.id !== latestReply.id && !leadingIds.has(reply.id),
+    );
+
+  const shown = new Set([
+    ...leadingIds,
+    ...trailingReplies.map((reply) => reply.id),
+    latestReply.id,
+  ]);
+
+  return {
+    leadingReplies,
+    trailingReplies,
+    latestReply,
+    // In thread order, so the gap link lands on the earliest post it stands
+    // for rather than somewhere in the middle of the run it hides.
+    firstHiddenReply: replies.find((reply) => !shown.has(reply.id)) ?? null,
+    hiddenCount: getThreadHiddenCount({
+      leadingReplies,
+      trailingReplies,
+      latestReply,
+      totalReplyCount: replies.length,
+    }),
+  };
+}

package/src/lib/time.ts

@@ -223,3 +223,35 @@ export function formatYearMonth(timestamp: number, timeZone = "UTC"): string {
   const month = parts.find((part) => part.type === "month")?.value ?? "01";
   return `${year}-${month}`;
 }
+
+/**
+ * Formats a "YYYY-MM" grouping key as a readable month label.
+ *
+ * The label is always en-US, matching the archive's other month copy — the
+ * grid header and the list marker read from this one function so their labels
+ * cannot drift apart.
+ *
+ * @param yearMonth - Year-month string in "YYYY-MM" format
+ * @returns Month label such as "February 2024", or null when the key is malformed
+ *
+ * @example
+ * ```ts
+ * const label = formatYearMonthLabel("2024-02");
+ * // Returns: "February 2024"
+ * ```
+ */
+export function formatYearMonthLabel(yearMonth: string): string | null {
+  const [year, month] = yearMonth.split("-");
+  if (!year || !month) return null;
+
+  const yearNumber = parseInt(year, 10);
+  const monthNumber = parseInt(month, 10);
+  if (!Number.isInteger(yearNumber) || !Number.isInteger(monthNumber)) {
+    return null;
+  }
+
+  return new Date(yearNumber, monthNumber - 1).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long",
+  });
+}

package/src/lib/timeline.ts

@@ -14,10 +14,25 @@ import type {
 } from "../types.js";
 import type { AppVariables } from "../types/app-context.js";
 import { buildMediaMap } from "./media-helpers.js";
-import { createMediaContext, toPostView } from "./view.js";
+import { createMediaContext, resolveDraftTailId, toPostView } from "./view.js";
+import { getViewLang } from "./view-language.js";
+import { toPublicPath } from "./url.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
+/**
+ * Language filter for the view the request is being served in.
+ *
+ * Read from the context rather than passed in, so a caller cannot forget it
+ * and quietly leak another language's posts into a language view.
+ *
+ * @param c - Hono context
+ * @returns Canonical tag to filter on, or undefined on the root view
+ */
+function viewLangFilter(c: Context<Env>): string | undefined {
+  return getViewLang(c) ?? undefined;
+}
+
 /**
  * Result from assembling a timeline page.
  */
@@ -51,13 +66,32 @@ async function buildTimelineItems(
   // Batch load media, collections, and latest-reply contexts in parallel
   const postIds = posts.map((p) => p.id);
   const mediaCtx = createMediaContext(c.var.appConfig);
-  const [rawMediaMap, collectionsMap, threadContexts, aliasesMap] =
-    await Promise.all([
-      c.var.services.media.getByPostIds(postIds),
-      c.var.services.collections.getCollectionsByPostIds(postIds),
-      c.var.services.posts.getThreadTimelineContext(postIds),
-      c.var.services.paths.getPostAliases(postIds),
-    ]);
+  const threadIds = posts.map((p) => p.threadId);
+  const [
+    rawMediaMap,
+    collectionsMap,
+    threadContexts,
+    aliasesMap,
+    publishedTails,
+    draftInclusiveTails,
+  ] = await Promise.all([
+    c.var.services.media.getByPostIds(postIds),
+    c.var.services.collections.getCollectionsByPostIds(postIds),
+    c.var.services.posts.getThreadTimelineContext(postIds),
+    c.var.services.paths.getPostAliases(postIds),
+    // The feed never renders drafts — it would turn a reading surface into a
+    // workspace. So the author's trailing draft stays hidden here, and the
+    // reply affordance carries its ID instead of silently offering a reply
+    // the server will refuse.
+    c.var.isAuthenticated
+      ? c.var.services.posts.getThreadTailIds(threadIds)
+      : Promise.resolve(new Map<string, string>()),
+    c.var.isAuthenticated
+      ? c.var.services.posts.getThreadTailIds(threadIds, {
+          includeDrafts: true,
+        })
+      : Promise.resolve(new Map<string, string>()),
+  ]);
   const mediaMap = buildMediaMap(
     rawMediaMap,
     mediaCtx.r2PublicUrl,
@@ -69,11 +103,15 @@ async function buildTimelineItems(
 
   // Batch load media for the bounded leading/trailing thread context.
   const contextPostIds = new Set<string>();
+  const gapPostIds = new Set<string>();
   for (const ctx of threadContexts.values()) {
     contextPostIds.add(ctx.latestReply.id);
     for (const reply of [...ctx.leadingReplies, ...ctx.trailingReplies]) {
       contextPostIds.add(reply.id);
     }
+    // The gap target is never rendered, so it needs no media or collections —
+    // only the alias that decides its address.
+    if (ctx.firstHiddenReply) gapPostIds.add(ctx.firstHiddenReply.id);
   }
   const [contextMediaMap, contextCollectionsMap, contextAliasesMap] =
     contextPostIds.size > 0
@@ -93,7 +131,12 @@ async function buildTimelineItems(
           c.var.services.collections.getCollectionsByPostIds([
             ...contextPostIds,
           ]),
-          c.var.services.paths.getPostAliases([...contextPostIds]),
+          // Gap targets ride along here and nowhere else: their address is
+          // all the gap link needs.
+          c.var.services.paths.getPostAliases([
+            ...contextPostIds,
+            ...gapPostIds,
+          ]),
         ])
       : [new Map(), new Map(), new Map<string, string[]>()];
 
@@ -113,6 +156,12 @@ async function buildTimelineItems(
       firstAlias(post.id),
     );
 
+    const draftTailId = resolveDraftTailId(
+      post.threadId,
+      publishedTails,
+      draftInclusiveTails,
+    );
+
     const threadCtx = threadContexts.get(post.id);
 
     if (threadCtx) {
@@ -142,9 +191,10 @@ async function buildTimelineItems(
         },
         mediaCtx,
         contextCollectionsMap.get(threadCtx.latestReply.id),
-        true, // latestReply is the last post in the thread
+        true, // latestReply is the last published post in the thread
         firstContextAlias(threadCtx.latestReply.id),
       );
+      if (draftTailId) latestReplyView.draftTailId = draftTailId;
 
       return {
         post: postView,
@@ -152,11 +202,21 @@ async function buildTimelineItems(
           leadingReplies: leadingReplyViews,
           trailingReplies: trailingReplyViews,
           latestReply: latestReplyView,
+          gapHref: threadCtx.firstHiddenReply
+            ? toPublicPath(
+                `/${firstContextAlias(threadCtx.firstHiddenReply.id) ?? threadCtx.firstHiddenReply.slug}`,
+                mediaCtx.sitePathPrefix,
+              )
+            : undefined,
           totalReplyCount: threadCtx.totalReplyCount,
         },
       };
     }
 
+    // No published replies, so the root carries the reply affordance — and any
+    // trailing draft with it.
+    if (draftTailId) postView.draftTailId = draftTailId;
+
     return { post: postView };
   });
 }
@@ -314,18 +374,22 @@ export async function assembleTimeline(
   const excludePrivate = !(options?.isAuthenticated ?? false);
 
   // Count + list are independent — run in parallel
+  const lang = viewLangFilter(c);
+
   const [totalCount, posts] = await Promise.all([
     c.var.services.posts.count({
       status: "published",
       excludeReplies: true,
       excludeLatestHidden: true,
       excludePrivate,
+      lang,
     }),
     c.var.services.posts.list({
       status: "published",
       excludeReplies: true,
       excludeLatestHidden: true,
       excludePrivate,
+      lang,
       limit: pageSize,
       offset,
     }),
@@ -390,14 +454,18 @@ export async function assembleFeaturedTimeline(
   const offset = (page - 1) * pageSize;
   const excludePrivate = !(options?.isAuthenticated ?? false);
 
+  const lang = viewLangFilter(c);
+
   const [totalCount, rootIds] = await Promise.all([
     c.var.services.posts.countFeaturedThreadRoots({
       status: "published",
       excludePrivate,
+      lang,
     }),
     c.var.services.posts.listFeaturedThreadRootIds({
       status: "published",
       excludePrivate,
+      lang,
       limit: pageSize,
       offset,
     }),
@@ -452,6 +520,7 @@ export async function assembleCollectionTimeline(
   const page = Math.max(1, options.page ?? 1);
   const offset = (page - 1) * pageSize;
   const excludePrivate = !(options.isAuthenticated ?? false);
+  const lang = viewLangFilter(c);
 
   const [totalCount, rootIds] = await Promise.all([
     c.var.services.posts.countCollectionThreadRootsForCollections(
@@ -459,6 +528,7 @@ export async function assembleCollectionTimeline(
       {
         status: "published",
         excludePrivate,
+        lang,
       },
     ),
     c.var.services.posts.listCollectionThreadRootIdsForCollections(
@@ -466,6 +536,7 @@ export async function assembleCollectionTimeline(
       {
         status: "published",
         excludePrivate,
+        lang,
         sortOrder: options.sortOrder,
         limit: pageSize,
         offset,

package/src/lib/tiptap-render.ts

@@ -14,7 +14,7 @@ import {
 import { renderEmbedFromAttrs } from "./embed-render.js";
 import { escapeHtml } from "./html.js";
 import { renderPublishedImageFigure } from "./rich-image.js";
-import { sanitizeUrl } from "./url.js";
+import { sanitizeRichTextHref } from "./url.js";
 
 interface TiptapMark {
   type: string;
@@ -48,8 +48,7 @@ export interface TiptapRenderOptions {
 }
 
 export type TiptapRenderResult =
-  | { ok: true; html: string }
-  | { ok: false; error: string };
+  { ok: true; html: string } | { ok: false; error: string };
 
 interface FootnoteReferencePlan {
   definitionId: string;
@@ -324,7 +323,9 @@ const MARK_RENDERERS: Record<string, MarkRenderer> = {
   strike: (html) => `<s>${html}</s>`,
   code: (html) => `<code>${html}</code>`,
   link: (html, mark) => {
-    const href = escapeHtml(sanitizeUrl(getStringAttr(mark.attrs, "href")));
+    const href = escapeHtml(
+      sanitizeRichTextHref(getStringAttr(mark.attrs, "href")),
+    );
     const target = getStringAttr(mark.attrs, "target");
     const targetAttr = target ? ` target="${escapeHtml(target)}"` : "";
     const relAttr = target ? ' rel="noopener noreferrer"' : "";