@jant/core 0.6.14 → 0.6.16

package/src/lib/markdown-manager.ts

@@ -7,6 +7,7 @@ import {
 } from "@tiptap/core";
 import { MarkdownManager } from "@tiptap/markdown";
 import CodeBlock from "@tiptap/extension-code-block";
+import Link from "@tiptap/extension-link";
 import StarterKit from "@tiptap/starter-kit";
 import {
   Table,
@@ -16,6 +17,7 @@ import {
 } from "@tiptap/extension-table";
 import {
   getFootnoteDefinitionLabelText,
+  getFootnoteLabelKey,
   getFootnoteReferenceText,
   indentFootnoteMarkdown,
   normalizeFootnoteArtifacts,
@@ -23,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,
@@ -217,6 +220,10 @@ const MarkdownCodeBlock = CodeBlock.extend({
   },
 });
 
+const SemanticLink = Link.extend({
+  clearable: false,
+});
+
 const MarkdownFigureImageSupport = Extension.create({
   name: "markdownFigureImageSupport",
 
@@ -539,6 +546,100 @@ function createFootnoteReferenceMarkdownToken() {
   };
 }
 
+const INLINE_FOOTNOTE_CONTENT_ATTR = "__jantInlineFootnoteContent";
+
+function parseInlineFootnoteSource(
+  src: string,
+): { content: string; raw: string } | null {
+  if (!src.startsWith("^[")) return null;
+
+  let bracketDepth = 1;
+  let codeDelimiterLength = 0;
+
+  for (let index = 2; index < src.length; index += 1) {
+    const character = src[index];
+
+    if (character === "\n" || character === "\r") return null;
+
+    if (character === "\\" && codeDelimiterLength === 0) {
+      index += 1;
+      continue;
+    }
+
+    if (character === "`") {
+      let delimiterLength = 1;
+      while (src[index + delimiterLength] === "`") {
+        delimiterLength += 1;
+      }
+
+      if (codeDelimiterLength === 0) {
+        codeDelimiterLength = delimiterLength;
+      } else if (codeDelimiterLength === delimiterLength) {
+        codeDelimiterLength = 0;
+      }
+
+      index += delimiterLength - 1;
+      continue;
+    }
+
+    if (codeDelimiterLength > 0) continue;
+
+    if (character === "[") {
+      bracketDepth += 1;
+      continue;
+    }
+
+    if (character !== "]") continue;
+    bracketDepth -= 1;
+    if (bracketDepth !== 0) continue;
+
+    const content = src.slice(2, index);
+    if (!content.trim()) return null;
+
+    return {
+      content,
+      raw: src.slice(0, index + 1),
+    };
+  }
+
+  return null;
+}
+
+const MarkdownInlineFootnote = Extension.create({
+  name: "inlineFootnote",
+
+  parseMarkdown: (token, helpers) =>
+    helpers.createNode("footnoteReference", {
+      [INLINE_FOOTNOTE_CONTENT_ATTR]: Array.isArray(token.tokens)
+        ? helpers.parseInline(token.tokens)
+        : [],
+    }),
+
+  markdownTokenizer: {
+    name: "inlineFootnote",
+    level: "inline",
+    start(src: string) {
+      return src.indexOf("^[");
+    },
+    tokenize(src: string, _tokens: unknown[], helpers) {
+      const inlineFootnote = parseInlineFootnoteSource(src);
+      if (!inlineFootnote) return undefined;
+
+      return {
+        type: "inlineFootnote",
+        raw: inlineFootnote.raw,
+        tokens: helpers.inlineTokens(inlineFootnote.content),
+      };
+    },
+  },
+});
+
+function normalizeFootnoteDataLabel(label: unknown): string {
+  const normalized = normalizeFootnoteLabel(label);
+  const legacyDisplayLabel = normalized.match(/^\[\^([^\]]+)\]:?$/)?.[1];
+  return normalizeFootnoteLabel(legacyDisplayLabel ?? normalized);
+}
+
 export const MarkdownFootnoteReference = Node.create({
   name: "footnoteReference",
   group: "inline",
@@ -560,7 +661,7 @@ export const MarkdownFootnoteReference = Node.create({
         getAttrs(dom) {
           const element = dom as QueryableElement;
           return {
-            label: normalizeFootnoteLabel(
+            label: normalizeFootnoteDataLabel(
               element.getAttribute("data-footnote-label"),
             ),
           };
@@ -615,7 +716,7 @@ export const MarkdownFootnoteDefinition = Node.create({
         getAttrs(dom) {
           const element = dom as QueryableElement;
           return {
-            label: normalizeFootnoteLabel(
+            label: normalizeFootnoteDataLabel(
               element.getAttribute("data-footnote-label"),
             ),
           };
@@ -631,7 +732,7 @@ export const MarkdownFootnoteDefinition = Node.create({
       "div",
       {
         "data-footnote-definition": "",
-        "data-footnote-label": getFootnoteDefinitionLabelText(label),
+        "data-footnote-label": label,
         class: "tiptap-footnote-definition",
       },
       0,
@@ -721,10 +822,15 @@ export function createMarkdownContentExtensions(
   return [
     StarterKit.configure({
       heading: { levels: [1, 2, 3] },
-      link: { openOnClick: false, autolink: false },
+      link: false,
       codeBlock: false,
       trailingNode: { notAfter: ["footnoteDefinition"] },
     }),
+    SemanticLink.configure({
+      openOnClick: false,
+      autolink: false,
+      isAllowedUri: (url) => sanitizeRichTextHref(url) !== "",
+    }),
     MarkdownCodeBlock,
     Table.configure({
       resizable: false,
@@ -738,11 +844,91 @@ export function createMarkdownContentExtensions(
     options.moreBreakExtension ?? MarkdownMoreBreak,
     options.embedExtension ?? MarkdownEmbedNode,
     options.htmlBlockExtension ?? MarkdownHtmlBlockNode,
+    MarkdownInlineFootnote,
     MarkdownFootnoteReference,
     MarkdownFootnoteDefinition,
   ];
 }
 
+function isJsonContent(value: unknown): value is JSONContent {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as { type?: unknown }).type === "string"
+  );
+}
+
+function collectUsedFootnoteLabels(
+  node: JSONContent,
+  usedLabels: Set<string>,
+): void {
+  if (node.type === "footnoteReference" || node.type === "footnoteDefinition") {
+    const label = normalizeFootnoteLabel(node.attrs?.label);
+    if (label) usedLabels.add(getFootnoteLabelKey(label));
+  }
+
+  for (const child of node.content ?? []) {
+    collectUsedFootnoteLabels(child, usedLabels);
+  }
+}
+
+function expandInlineFootnotes(doc: JSONContent): JSONContent {
+  if (doc.type !== "doc") return doc;
+
+  const usedLabels = new Set<string>();
+  collectUsedFootnoteLabels(doc, usedLabels);
+  const definitions: JSONContent[] = [];
+  let nextNumericLabel = 1;
+
+  const allocateLabel = (): string => {
+    while (usedLabels.has(getFootnoteLabelKey(String(nextNumericLabel)))) {
+      nextNumericLabel += 1;
+    }
+
+    const label = String(nextNumericLabel);
+    usedLabels.add(getFootnoteLabelKey(label));
+    nextNumericLabel += 1;
+    return label;
+  };
+
+  const expandNode = (node: JSONContent): JSONContent => {
+    const inlineContent = node.attrs?.[INLINE_FOOTNOTE_CONTENT_ATTR];
+
+    if (node.type === "footnoteReference" && Array.isArray(inlineContent)) {
+      const label = allocateLabel();
+      const attrs: Record<string, unknown> = { ...(node.attrs ?? {}), label };
+      delete attrs[INLINE_FOOTNOTE_CONTENT_ATTR];
+      const content = inlineContent
+        .filter(isJsonContent)
+        .map((child) => expandNode(normalizeMarkdownDocument(child)));
+
+      definitions.push({
+        type: "footnoteDefinition",
+        attrs: { label },
+        content: [
+          content.length > 0
+            ? { type: "paragraph", content }
+            : { type: "paragraph" },
+        ],
+      });
+
+      return { ...node, attrs };
+    }
+
+    return node.content
+      ? { ...node, content: node.content.map(expandNode) }
+      : node;
+  };
+
+  const expanded = expandNode(doc);
+  if (definitions.length === 0) return expanded;
+
+  return {
+    ...expanded,
+    content: [...(expanded.content ?? []), ...definitions],
+  };
+}
+
 /**
  * Normalizes Markdown parser output before it enters the editor schema.
  *
@@ -839,7 +1025,9 @@ export function normalizeMarkdownDocument(node: JSONContent): JSONContent {
     normalized.content = nextContent;
   }
 
-  return normalized;
+  return normalized.type === "doc"
+    ? expandInlineFootnotes(normalized)
+    : normalized;
 }
 
 function expandCodeBlockFences(markdown: string): string {

package/src/lib/markdown.ts

@@ -8,12 +8,16 @@
 
 import { parseMarkdownDocument } from "./markdown-manager.js";
 import { extractBodyText } from "./summary.js";
-import { renderTiptapDocument } from "./tiptap-render.js";
+import {
+  renderTiptapDocument,
+  type TiptapRenderOptions,
+} from "./tiptap-render.js";
 
 /**
  * Renders Markdown content to HTML using Jant's shared Markdown pipeline.
  *
  * @param markdown - The Markdown string to convert to HTML
+ * @param options - Rendering options, including a stable footnote namespace
  * @returns The rendered HTML string
  *
  * @example
@@ -22,9 +26,12 @@ import { renderTiptapDocument } from "./tiptap-render.js";
  * // "<h1>Hello</h1><p>This is <strong>bold</strong> text.</p>"
  * ```
  */
-export function render(markdown: string): string {
+export function render(
+  markdown: string,
+  options: TiptapRenderOptions = {},
+): string {
   if (!markdown.trim()) return "";
-  return renderTiptapDocument(parseMarkdownDocument(markdown));
+  return renderTiptapDocument(parseMarkdownDocument(markdown), options);
 }
 
 /**

package/src/lib/navigation.ts

@@ -53,10 +53,17 @@ export async function getNavigationData(
 ): Promise<NavigationData> {
   // Callers that already fetched nav items can pass them in to avoid a
   // redundant DB round-trip.
-  const items =
+  const savedItems =
     options?.preloadedItems ?? (await c.var.services.navItems.list());
   const currentPath = c.var.publicPath;
   const appConfig = c.var.appConfig;
+  // Keep the saved RSS item untouched so its placement and custom label come
+  // back when feeds are re-enabled. Only the rendered projection is filtered.
+  const items = appConfig.rssFeedsEnabled
+    ? savedItems
+    : savedItems.filter(
+        (item: NavItem) => item.type !== "system" || item.systemKey !== "rss",
+      );
 
   const siteName = appConfig.siteName;
   const siteFooter = appConfig.siteFooter;
@@ -68,7 +75,9 @@ export async function getNavigationData(
   // Plain text for meta tags / RSS; HTML for homepage display
   const siteDescription = rawDescription ? toPlainText(rawDescription) : "";
   const siteDescriptionHtml = rawDescription
-    ? renderMarkdown(rawDescription)
+    ? renderMarkdown(rawDescription, {
+        namespace: `${c.var.currentSite.id}-description`,
+      })
     : undefined;
 
   // Avatar URL and display flag come from appConfig
@@ -76,7 +85,11 @@ export async function getNavigationData(
   const showHeaderAvatar = appConfig.showHeaderAvatar;
 
   // Render footer markdown
-  const siteFooterHtml = siteFooter ? renderMarkdown(siteFooter) : undefined;
+  const siteFooterHtml = siteFooter
+    ? renderMarkdown(siteFooter, {
+        namespace: `${c.var.currentSite.id}-footer`,
+      })
+    : undefined;
 
   // Auth state is populated once per request by `attachSession` middleware.
   const isAuthenticated = c.var.isAuthenticated;

package/src/lib/post-body-html.ts

@@ -0,0 +1,131 @@
+/**
+ * Stored post body HTML projection helpers.
+ *
+ * TipTap JSON in `post.body` is canonical. `post.body_html` is a materialized
+ * projection that may lag behind the current renderer during upgrades or after
+ * importing an older snapshot.
+ */
+
+import type { JSONContent } from "@tiptap/core";
+import { upgradeLegacyFootnotes } from "./footnotes.js";
+import {
+  renderTiptapDocument,
+  type TiptapRenderResult,
+} from "./tiptap-render.js";
+
+/** Current persisted post body HTML contract. V1 is the legacy inline trio. */
+export const POST_BODY_HTML_VERSION = 4;
+
+export type PreparedPostBodyHtmlResult =
+  | {
+      ok: true;
+      body: string;
+      html: string;
+      upgradedLegacyFootnotes: boolean;
+    }
+  | { ok: false; error: string };
+
+export interface StoredPostBodyHtml {
+  id: string;
+  body: string | null;
+  bodyHtml: string | null;
+  bodyHtmlVersion: number | null;
+}
+
+/**
+ * Render canonical post JSON with a stable page-wide footnote namespace.
+ *
+ * @param postId - Immutable post TypeID
+ * @param body - Canonical TipTap JSON
+ * @returns Current public HTML, or an empty string for invalid JSON
+ * @example
+ * ```ts
+ * renderPostBodyHtml("pst_example", '{"type":"doc","content":[]}');
+ * // ""
+ * ```
+ */
+export function renderPostBodyHtml(postId: string, body: string): string {
+  const result = tryPreparePostBodyHtml(postId, body);
+  return result.ok ? result.html : "";
+}
+
+/**
+ * Normalize recognized historical footnotes and render the current HTML
+ * projection in one parse pass.
+ *
+ * @param postId - Immutable post TypeID
+ * @param body - Canonical TipTap JSON
+ * @returns Prepared canonical JSON and HTML, or a parse failure
+ * @example
+ * ```ts
+ * tryPreparePostBodyHtml("pst_example", '{"type":"doc","content":[]}');
+ * // { ok: true, body: "...", html: "", upgradedLegacyFootnotes: false }
+ * ```
+ */
+export function tryPreparePostBodyHtml(
+  postId: string,
+  body: string,
+): PreparedPostBodyHtmlResult {
+  try {
+    const parsed = JSON.parse(body) as JSONContent;
+    if (parsed.type !== "doc") {
+      return { ok: false, error: "TipTap body root must be a doc node." };
+    }
+
+    const upgraded = upgradeLegacyFootnotes(parsed);
+    return {
+      ok: true,
+      body: upgraded.upgraded ? JSON.stringify(upgraded.doc) : body,
+      html: renderTiptapDocument(upgraded.doc, { namespace: postId }),
+      upgradedLegacyFootnotes: upgraded.upgraded,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : "Invalid TipTap JSON.",
+    };
+  }
+}
+
+/**
+ * Strict variant used by projection rebuilds.
+ *
+ * @param postId - Immutable post TypeID
+ * @param body - Canonical TipTap JSON
+ * @returns A result that distinguishes malformed JSON from a valid empty body
+ */
+export function tryRenderPostBodyHtml(
+  postId: string,
+  body: string,
+): TiptapRenderResult {
+  const result = tryPreparePostBodyHtml(postId, body);
+  return result.ok
+    ? { ok: true, html: result.html }
+    : { ok: false, error: result.error };
+}
+
+/**
+ * Resolve a stored projection to the current public HTML contract.
+ *
+ * Stale rows are rendered in memory so a partially completed backfill never
+ * leaks mixed HTML-contract markup. Invalid historical canonical JSON falls back to the
+ * stored HTML for availability; the strict rebuild reports those rows instead
+ * of marking them current.
+ *
+ * @param input - Stored post body and projection fields
+ * @returns Current rendered HTML, the legacy fallback, or null for no body
+ */
+export function resolvePostBodyHtml(input: StoredPostBodyHtml): string | null {
+  if (input.body === null) return null;
+
+  if (
+    input.bodyHtmlVersion !== null &&
+    input.bodyHtmlVersion >= POST_BODY_HTML_VERSION &&
+    input.bodyHtml !== null
+  ) {
+    return input.bodyHtml;
+  }
+
+  const result = tryRenderPostBodyHtml(input.id, input.body);
+  return result.ok ? result.html : input.bodyHtml;
+}

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,6 +82,13 @@ function resolvePostSocialImage(
 interface PostDisplayOptions {
   isAuthenticated?: boolean;
   allowDraft?: boolean;
+  /**
+   * 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;
 }
 
 function canViewPost(post: Post, options: PostDisplayOptions = {}): boolean {
@@ -118,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]),
     ]);
 
@@ -142,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;
 }
 
@@ -168,9 +187,20 @@ 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");
+  ).filter(
+    (threadPost) =>
+      threadPost.status === "published" ||
+      (includeDrafts && threadPost.status === "draft"),
+  );
 
   const allPostIds =
     threadPosts.length > 1 ? threadPosts.map((p) => p.id) : [post.id];
@@ -213,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/render.tsx

@@ -49,12 +49,16 @@ export interface RenderPublicPageOptions {
   navData: NavigationData;
   /** Page content JSX to render inside SiteLayout */
   content: Child;
+  /** Optional status chrome rendered outside the public site layout. */
+  pageChrome?: Child;
   /** Optional sidebar content for sidebar layout */
   sidebar?: Child;
   /** Optional toast notification */
   toast?: ToastProps;
   /** Whether to render the shared compose dialog shell */
   showComposeDialog?: boolean;
+  /** Override the site-wide crawler setting for sensitive utility pages. */
+  noindex?: boolean;
   /** Whether to render the site header */
   showHeader?: boolean;
   /** Whether to render the home branding credit after the site footer */
@@ -97,9 +101,11 @@ export function renderPublicPage(c: Context, options: RenderPublicPageOptions) {
     canonicalHref,
     navData,
     content,
+    pageChrome,
     sidebar,
     toast,
     showComposeDialog,
+    noindex,
     showHeader,
     showHomeBranding,
     composeCollectionId,
@@ -138,7 +144,7 @@ export function renderPublicPage(c: Context, options: RenderPublicPageOptions) {
   };
   const faviconUrl = appConfig.siteAvatarUrl || undefined;
   const faviconVersion = appConfig.faviconVersion || undefined;
-  const noindex = appConfig.noindex;
+  const resolvedNoindex = noindex ?? appConfig.noindex;
 
   return c.html(
     <BaseLayout
@@ -158,10 +164,11 @@ export function renderPublicPage(c: Context, options: RenderPublicPageOptions) {
       canonicalHref={canonicalHref}
       faviconUrl={faviconUrl}
       faviconVersion={faviconVersion}
-      noindex={noindex}
+      noindex={resolvedNoindex}
       isAuthenticated={navData.isAuthenticated}
       toast={toast}
     >
+      {pageChrome}
       <SiteLayout {...layoutProps}>{content}</SiteLayout>
     </BaseLayout>,
   );