@jant/core 0.6.13 → 0.6.15

package/src/lib/github-sync-site-config.ts

@@ -30,6 +30,8 @@ export async function buildSyncSiteConfig(c: {
     siteDescription: appConfig.siteDescription,
     siteLanguage: appConfig.siteLanguage,
     showJantBrandingOnHome: appConfig.showJantBrandingOnHome,
+    publicApiEnabled: appConfig.publicApiEnabled,
+    rssFeedsEnabled: appConfig.rssFeedsEnabled,
     mainRssFeed: appConfig.mainRssFeed,
     siteFooter: appConfig.siteFooter,
     showHeaderAvatar: appConfig.showHeaderAvatar,

package/src/lib/hugo-markdown.ts

@@ -16,8 +16,9 @@
 // ---------------------------------------------------------------------------
 
 /**
- * Per-collection membership metadata. Preserved verbatim on round-trip so
- * curators keep their collected_at / position / pinned_at ordering.
+ * Per-Thread collection membership metadata. Current exports write this
+ * only on the Thread root bundle. Import also accepts legacy reply-level
+ * entries and folds them into the root without losing metadata.
  */
 export interface HugoCollectionRef {
   slug: string;
@@ -111,10 +112,14 @@ export interface HugoFrontMatter {
   featured_at?: string | null;
   pinned_at?: string | null;
 
+  // Derived Featured Thread projection (root bundles only)
+  featured_post_ids?: string[];
+  featured_sort_at?: string;
+
   // Round-trip bookkeeping
   root_aliases?: string[];
 
-  // Memberships + attachments
+  // Thread memberships (root bundles only) + attachments
   collections?: HugoCollectionRef[];
   media?: JantMedia[];
 
@@ -201,6 +206,8 @@ const FRONT_MATTER_KEY_ORDER: readonly string[] = [
   "quote_text",
   "rating",
   "featured_at",
+  "featured_post_ids",
+  "featured_sort_at",
   "pinned_at",
 
   // Bookkeeping / attachments

package/src/lib/jant-branding.ts

@@ -23,6 +23,7 @@ import { toPublicPath } from "./url.js";
 
 export { JANT_APP_ICON_CORNER_RADIUS, JANT_LOGO_PATH_DATA, JANT_LOGO_VIEW_BOX };
 
+export const JANT_HOME_URL = "https://jant.me";
 export const JANT_REPO_URL = "https://github.com/jant-me/jant";
 export const HOME_BRANDING_PREFIX = "Build with";
 export const HOME_BRANDING_LINK_LABEL = "Jant";

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,
@@ -217,6 +219,10 @@ const MarkdownCodeBlock = CodeBlock.extend({
   },
 });
 
+const SemanticLink = Link.extend({
+  clearable: false,
+});
+
 const MarkdownFigureImageSupport = Extension.create({
   name: "markdownFigureImageSupport",
 
@@ -539,6 +545,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 +660,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 +715,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 +731,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,9 +821,11 @@ 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 }),
     MarkdownCodeBlock,
     Table.configure({
       resizable: false,
@@ -737,16 +839,104 @@ export function createMarkdownContentExtensions(
     options.moreBreakExtension ?? MarkdownMoreBreak,
     options.embedExtension ?? MarkdownEmbedNode,
     options.htmlBlockExtension ?? MarkdownHtmlBlockNode,
+    MarkdownInlineFootnote,
     MarkdownFootnoteReference,
     MarkdownFootnoteDefinition,
   ];
 }
 
-function normalizeMarkdownDoc(node: JSONContent): JSONContent {
+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.
+ *
+ * @param node - Parsed Tiptap document or descendant node
+ * @returns A normalized copy safe to load into an editor
+ * @example
+ * const normalized = normalizeMarkdownDocument(markdownManager.parse(source));
+ */
+export function normalizeMarkdownDocument(node: JSONContent): JSONContent {
   const normalized: JSONContent = { ...node };
 
   if (normalized.content) {
-    normalized.content = normalized.content.map(normalizeMarkdownDoc);
+    normalized.content = normalized.content.map(normalizeMarkdownDocument);
   }
 
   if (normalized.marks) {
@@ -810,9 +1000,9 @@ function normalizeMarkdownDoc(node: JSONContent): JSONContent {
         child?.type === "text" &&
         typeof child.text === "string" &&
         nextChild?.type === "footnoteReference" &&
-        child.text.endsWith("\n")
+        /\n[ \t]*$/.test(child.text)
       ) {
-        const trimmedText = child.text.replace(/\n$/, "");
+        const trimmedText = child.text.replace(/\n[ \t]*$/, "");
         if (trimmedText) {
           nextContent.push({
             ...child,
@@ -830,7 +1020,9 @@ function normalizeMarkdownDoc(node: JSONContent): JSONContent {
     normalized.content = nextContent;
   }
 
-  return normalized;
+  return normalized.type === "doc"
+    ? expandInlineFootnotes(normalized)
+    : normalized;
 }
 
 function expandCodeBlockFences(markdown: string): string {
@@ -854,7 +1046,7 @@ export function getMarkdownManager(): MarkdownManager {
 }
 
 export function parseMarkdownDocument(markdown: string): JSONContent {
-  return normalizeMarkdownDoc(getMarkdownManager().parse(markdown));
+  return normalizeMarkdownDocument(getMarkdownManager().parse(markdown));
 }
 
 export function serializeMarkdownDocument(doc: JSONContent): 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

@@ -82,6 +82,8 @@ function resolvePostSocialImage(
 interface PostDisplayOptions {
   isAuthenticated?: boolean;
   allowDraft?: boolean;
+  /** Include draft members when assembling a thread for an authenticated preview. */
+  includeDraftThread?: boolean;
 }
 
 function canViewPost(post: Post, options: PostDisplayOptions = {}): boolean {
@@ -170,7 +172,11 @@ export async function assemblePostPageDisplay(
   const mediaCtx = createMediaContext(c.var.appConfig);
   const threadPosts = (
     await c.var.services.posts.getThread(post.threadId)
-  ).filter((threadPost) => threadPost.status === "published");
+  ).filter(
+    (threadPost) =>
+      threadPost.status === "published" ||
+      (options?.includeDraftThread && threadPost.status === "draft"),
+  );
 
   const allPostIds =
     threadPosts.length > 1 ? threadPosts.map((p) => p.id) : [post.id];

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>,
   );