@jant/core 0.6.15 → 0.6.16

package/src/lib/feed.ts

@@ -11,6 +11,7 @@
  */
 
 import type { FeedData, FeedPostView, MediaView, PostView } from "../types.js";
+import { getLinkPreviewProviderLabel } from "./link-preview.js";
 import { extractDisplayDomain } from "./url.js";
 import { getMediaCategory } from "./upload.js";
 
@@ -40,6 +41,49 @@ function escapeCdata(str: string): string {
   return str.replaceAll("]]>", "]]]]><![CDATA[>");
 }
 
+/**
+ * Resolve a URL for use outside the feed document's browser context.
+ *
+ * Feed readers do not consistently resolve root-relative URLs found inside
+ * Atom HTML content or enclosure attributes, so every non-fragment URL must
+ * carry its own origin.
+ */
+function toAbsoluteFeedUrl(url: string, siteUrl: string): string {
+  const normalizedUrl = url.trim();
+  if (!normalizedUrl || normalizedUrl.startsWith("#")) return normalizedUrl;
+
+  try {
+    const baseUrl = siteUrl.endsWith("/") ? siteUrl : `${siteUrl}/`;
+    return new URL(normalizedUrl, baseUrl).toString();
+  } catch {
+    return normalizedUrl;
+  }
+}
+
+/**
+ * Resolve navigational and media URL attributes inside trusted post HTML.
+ *
+ * Fragment-only links stay local to the rendered feed entry so footnotes and
+ * other in-entry references continue to work.
+ */
+function absolutizeFeedHtmlUrls(html: string, siteUrl: string): string {
+  return html.replaceAll(
+    /(\s)(href|poster|src)=(["'])([^"']*)\3/gi,
+    (
+      match,
+      whitespace: string,
+      attribute: string,
+      quote: string,
+      url: string,
+    ) => {
+      const absoluteUrl = toAbsoluteFeedUrl(url, siteUrl);
+      return absoluteUrl
+        ? `${whitespace}${attribute}=${quote}${absoluteUrl}${quote}`
+        : match;
+    },
+  );
+}
+
 /**
  * Strip embedded content that is unsafe or unsupported in feed readers.
  *
@@ -144,6 +188,35 @@ function renderRatingHtml(rating: number): string {
   return `<p>${filled}${empty} ${rating}/5</p>`;
 }
 
+/**
+ * Render a Link post preview as feed-safe HTML.
+ *
+ * Feed readers commonly strip CSS overlays and embedded players, so video
+ * previews use a linked thumbnail plus a visible provider-aware action.
+ * Non-video Link previews keep the linked thumbnail without a video label.
+ */
+function renderLinkPreviewForFeed(post: PostView, siteUrl: string): string {
+  if (post.format !== "link") return "";
+
+  const imageUrl = post.previewImageUrl?.trim();
+  const linkUrl = post.url?.trim();
+  if (!imageUrl || !linkUrl) return "";
+
+  const isVideo = post.previewKind?.trim().toLowerCase() === "video";
+  const providerLabel = getLinkPreviewProviderLabel(post.previewProvider);
+  const fallbackAlt = isVideo
+    ? providerLabel
+      ? `${providerLabel} video`
+      : "Video preview"
+    : "Link preview";
+  const altText = post.title?.trim() || fallbackAlt;
+  const caption = isVideo
+    ? `<figcaption><a href="${escapeXml(linkUrl)}">▶ ${providerLabel ? `Watch on ${providerLabel}` : "Watch video"}</a></figcaption>`
+    : "";
+
+  return `<figure><a href="${escapeXml(linkUrl)}"><img src="${escapeXml(toAbsoluteFeedUrl(imageUrl, siteUrl))}" alt="${escapeXml(altText)}"/></a>${caption}</figure>`;
+}
+
 function formatFeedBytes(bytes: number): string {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
@@ -203,9 +276,13 @@ function buildAttachmentLinkText(
  *   and duration metadata when known. Text attachments link to the rendered
  *   preview page when a post permalink is available.
  */
-function renderMediaItem(item: MediaView, postPermalinkUrl?: string): string {
+function renderMediaItem(
+  item: MediaView,
+  siteUrl: string,
+  postPermalinkUrl?: string,
+): string {
   const category = getMediaCategory(item.mimeType);
-  const url = escapeXml(item.url);
+  const url = escapeXml(toAbsoluteFeedUrl(item.url, siteUrl));
   const name = item.originalName ?? "";
   const altText = item.altText ?? "";
   const caption = item.altText?.trim() || "";
@@ -223,7 +300,10 @@ function renderMediaItem(item: MediaView, postPermalinkUrl?: string): string {
   }
 
   if (category === "video") {
-    const poster = item.posterUrl || item.thumbnailUrl;
+    const poster = toAbsoluteFeedUrl(
+      item.posterUrl || item.thumbnailUrl,
+      siteUrl,
+    );
     const dims =
       item.width && item.height
         ? ` width="${item.width}" height="${item.height}"`
@@ -272,11 +352,12 @@ function renderMediaItem(item: MediaView, postPermalinkUrl?: string): string {
  */
 function renderMediaForFeed(
   media: MediaView[],
+  siteUrl: string,
   postPermalinkUrl?: string,
 ): string {
   if (media.length === 0) return "";
   return media
-    .map((item) => renderMediaItem(item, postPermalinkUrl))
+    .map((item) => renderMediaItem(item, siteUrl, postPermalinkUrl))
     .join("\n");
 }
 
@@ -289,6 +370,7 @@ function renderMediaForFeed(
  */
 function buildSinglePostContent(
   post: PostView,
+  siteUrl: string,
   permalinkUrl?: string,
   options: SinglePostContentOptions = {},
 ): string {
@@ -314,11 +396,18 @@ function buildSinglePostContent(
     }
   }
 
+  const linkPreviewHtml = renderLinkPreviewForFeed(post, siteUrl);
+  if (linkPreviewHtml) {
+    parts.push(linkPreviewHtml);
+  }
+
   if (post.bodyHtml) {
-    parts.push(stripUnsafeFeedHtml(post.bodyHtml));
+    parts.push(
+      absolutizeFeedHtmlUrls(stripUnsafeFeedHtml(post.bodyHtml), siteUrl),
+    );
   }
 
-  const mediaHtml = renderMediaForFeed(post.media, permalinkUrl);
+  const mediaHtml = renderMediaForFeed(post.media, siteUrl, permalinkUrl);
   if (mediaHtml) {
     parts.push(mediaHtml);
   }
@@ -353,7 +442,7 @@ function buildFeedContent(
   siteUrl: string,
   permalinkUrl?: string,
 ): string {
-  const rootContent = buildSinglePostContent(post, permalinkUrl);
+  const rootContent = buildSinglePostContent(post, siteUrl, permalinkUrl);
   const replies = post.threadReplies;
 
   if (!replies || replies.length === 0) {
@@ -368,7 +457,9 @@ function buildFeedContent(
     parts.push(
       `<p><small><time datetime="${escapeXml(reply.publishedAt)}">${escapeXml(reply.publishedAtFormatted)}</time></small></p>`,
     );
-    parts.push(buildSinglePostContent(reply, replyPermalink, { inline: true }));
+    parts.push(
+      buildSinglePostContent(reply, siteUrl, replyPermalink, { inline: true }),
+    );
   }
 
   return parts.join("\n");
@@ -421,7 +512,7 @@ export function defaultFeedRenderer(data: FeedData): string {
           const titleAttr = m.originalName
             ? ` title="${escapeXml(m.originalName)}"`
             : "";
-          return `\n    <link rel="enclosure" type="${escapeXml(m.mimeType)}" href="${escapeXml(m.url)}"${lengthAttr}${titleAttr}/>`;
+          return `\n    <link rel="enclosure" type="${escapeXml(m.mimeType)}" href="${escapeXml(toAbsoluteFeedUrl(m.url, siteUrl))}"${lengthAttr}${titleAttr}/>`;
         })
         .join("");
 
@@ -438,7 +529,18 @@ export function defaultFeedRenderer(data: FeedData): string {
     })
     .join("");
 
-  const now = new Date().toISOString();
+  // The feed's own <updated> is the newest entry timestamp, not the current
+  // time — stamping "now" on every render tells every reader the feed changed
+  // on every poll, which is both untrue and useless for change detection.
+  // ISO 8601 from toISOString() is UTC and zero-padded, so lexical max is
+  // chronological max. Empty feeds fall back to now, since Atom requires it.
+  const feedUpdated =
+    posts
+      .map((post) => post.feedUpdatedAt ?? post.updatedAt)
+      .reduce<
+        string | null
+      >((latest, value) => (latest === null || value > latest ? value : latest), null) ??
+    new Date().toISOString();
 
   return `<?xml version="1.0" encoding="UTF-8"?>
 <feed xmlns="http://www.w3.org/2005/Atom">
@@ -447,7 +549,7 @@ export function defaultFeedRenderer(data: FeedData): string {
   <link href="${escapeXml(siteUrl)}" rel="alternate"/>
   <link href="${escapeXml(selfUrl)}" rel="self"/>
   <id>${escapeXml(selfUrl)}</id>
-  <updated>${now}</updated>
+  <updated>${feedUpdated}</updated>
   ${entries}
 </feed>`;
 }

package/src/lib/hugo-markdown.ts

@@ -111,6 +111,11 @@ export interface HugoFrontMatter {
   rating?: number | null;
   featured_at?: string | null;
   pinned_at?: string | null;
+  /**
+   * Reply bundles only: the reply was published without announcing the Thread
+   * on Latest. Round-tripped so a restore rebuilds the same ordering.
+   */
+  quiet_reply?: boolean;
 
   // Derived Featured Thread projection (root bundles only)
   featured_post_ids?: string[];

package/src/lib/link-preview.ts

@@ -0,0 +1,25 @@
+const LINK_PREVIEW_PROVIDER_LABELS: Record<string, string> = {
+  youtube: "YouTube",
+  vimeo: "Vimeo",
+  bilibili: "Bilibili",
+};
+
+/**
+ * Return the display label for a recognized Link preview provider.
+ *
+ * @param provider - Stored provider identifier, such as `youtube`
+ * @returns A stable display label, or undefined for unknown providers
+ * @example
+ * ```ts
+ * getLinkPreviewProviderLabel("youtube"); // "YouTube"
+ * getLinkPreviewProviderLabel("unknown"); // undefined
+ * ```
+ */
+export function getLinkPreviewProviderLabel(
+  provider?: string,
+): string | undefined {
+  const normalizedProvider = provider?.trim().toLowerCase();
+  return normalizedProvider
+    ? LINK_PREVIEW_PROVIDER_LABELS[normalizedProvider]
+    : undefined;
+}

package/src/lib/markdown-manager.ts

@@ -25,6 +25,7 @@ import {
   parseFootnoteDefinition,
 } from "./footnotes.js";
 import { renderMarkdownImage, type RichImageAttrs } from "./rich-image.js";
+import { sanitizeRichTextHref } from "./url.js";
 
 export const MARKDOWN_MARKED_OPTIONS = {
   gfm: true,
@@ -825,7 +826,11 @@ export function createMarkdownContentExtensions(
       codeBlock: false,
       trailingNode: { notAfter: ["footnoteDefinition"] },
     }),
-    SemanticLink.configure({ openOnClick: false, autolink: false }),
+    SemanticLink.configure({
+      openOnClick: false,
+      autolink: false,
+      isAllowedUri: (url) => sanitizeRichTextHref(url) !== "",
+    }),
     MarkdownCodeBlock,
     Table.configure({
       resizable: false,

package/src/lib/post-display.ts

@@ -9,7 +9,7 @@ import type { Context } from "hono";
 import type { Bindings, Post, PostView } 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";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
@@ -82,7 +82,12 @@ function resolvePostSocialImage(
 interface PostDisplayOptions {
   isAuthenticated?: boolean;
   allowDraft?: boolean;
-  /** Include draft members when assembling a thread for an authenticated preview. */
+  /**
+   * Force draft members into the assembled thread. The author already sees
+   * them whenever they are signed in; this only covers the draft-preview
+   * route, where the request is authenticated but `isAuthenticated` has
+   * already been forced to `true` for private-post access.
+   */
   includeDraftThread?: boolean;
 }
 
@@ -120,11 +125,16 @@ export async function assemblePostCardView(
   }
 
   const mediaCtx = createMediaContext(c.var.appConfig);
-  const [rawMediaMap, collectionsMap, lastPostMap, aliasesMap] =
+  const [rawMediaMap, collectionsMap, lastPostMap, draftTailMap, aliasesMap] =
     await Promise.all([
       c.var.services.media.getByPostIds([post.id]),
       c.var.services.collections.getCollectionsByPostIds([post.id]),
-      c.var.services.posts.getLastPostIdsByThread([post.threadId]),
+      c.var.services.posts.getThreadTailIds([post.threadId]),
+      c.var.isAuthenticated
+        ? c.var.services.posts.getThreadTailIds([post.threadId], {
+            includeDrafts: true,
+          })
+        : Promise.resolve(new Map<string, string>()),
       c.var.services.paths.getPostAliases([post.id]),
     ]);
 
@@ -144,6 +154,13 @@ export async function assemblePostCardView(
     aliasesMap.get(post.id)?.[0],
   );
 
+  const draftTailId = resolveDraftTailId(
+    post.threadId,
+    lastPostMap,
+    draftTailMap,
+  );
+  if (draftTailId) view.draftTailId = draftTailId;
+
   return view;
 }
 
@@ -170,12 +187,19 @@ export async function assemblePostPageDisplay(
   }
 
   const mediaCtx = createMediaContext(c.var.appConfig);
+  // Drafts render for the author so the thread they see ends where the server
+  // thinks it ends — otherwise a trailing draft silently blocks replies while
+  // staying invisible. Read the real auth state rather than the option, which
+  // callers force to `true` to bypass the private-post check.
+  const includeDrafts = Boolean(
+    options?.includeDraftThread || c.var.isAuthenticated,
+  );
   const threadPosts = (
     await c.var.services.posts.getThread(post.threadId)
   ).filter(
     (threadPost) =>
       threadPost.status === "published" ||
-      (options?.includeDraftThread && threadPost.status === "draft"),
+      (includeDrafts && threadPost.status === "draft"),
   );
 
   const allPostIds =
@@ -219,13 +243,22 @@ export async function assemblePostPageDisplay(
         )
       : undefined;
 
-  const socialImage = resolvePostSocialImage(postView, threadPostViews);
+  // Page metadata describes what a reader gets, so it never draws on drafts:
+  // an unpublished reply must not supply the og:image or bump the modified
+  // time. Falls back to the post itself when nothing in the thread is
+  // published (the draft-preview route, which is noindex anyway).
+  const publishedViews = threadPostViews?.filter(
+    (view) => view.status === "published",
+  );
+  const metaViews = publishedViews?.length ? publishedViews : [postView];
+
+  const socialImage = resolvePostSocialImage(postView, metaViews);
 
-  const rootView = threadPostViews?.[0] ?? postView;
-  const allViews = threadPostViews ?? [postView];
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- metaViews is never empty
+  const rootView = metaViews[0]!;
   // ISO 8601 strings from toISOString() are all UTC and zero-padded, so
   // lexical comparison matches chronological order.
-  const articleModifiedTime = allViews
+  const articleModifiedTime = metaViews
     .map((p) => p.updatedAt)
     .reduce((latest, t) => (t > latest ? t : latest));
 

package/src/lib/timeline.ts

@@ -14,7 +14,7 @@ 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";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
@@ -51,13 +51,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,
@@ -113,6 +132,12 @@ async function buildTimelineItems(
       firstAlias(post.id),
     );
 
+    const draftTailId = resolveDraftTailId(
+      post.threadId,
+      publishedTails,
+      draftInclusiveTails,
+    );
+
     const threadCtx = threadContexts.get(post.id);
 
     if (threadCtx) {
@@ -142,9 +167,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,
@@ -157,6 +183,10 @@ async function buildTimelineItems(
       };
     }
 
+    // No published replies, so the root carries the reply affordance — and any
+    // trailing draft with it.
+    if (draftTailId) postView.draftTailId = draftTailId;
+
     return { post: postView };
   });
 }

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;
@@ -324,7 +324,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"' : "";