@jant/core 0.6.14 → 0.6.16

package/src/lib/__tests__/feed.test.ts

@@ -51,6 +51,48 @@ function makeFeedData(post: FeedPostView): FeedData {
 }
 
 describe("feed renderers", () => {
+  // Stamping the render time on <updated> tells every reader the feed changed
+  // on every poll, which is untrue and useless for change detection.
+  it("dates the feed by its newest entry, not the render time", () => {
+    const xml = defaultFeedRenderer({
+      ...makeFeedData(makePostView()),
+      posts: [
+        makePostView({
+          id: "a",
+          permalink: "/a",
+          feedUpdatedAt: "2026-01-02T00:00:00.000Z",
+        }),
+        makePostView({
+          id: "b",
+          permalink: "/b",
+          feedUpdatedAt: "2026-05-09T00:00:00.000Z",
+        }),
+        makePostView({
+          id: "c",
+          permalink: "/c",
+          feedUpdatedAt: "2026-03-04T00:00:00.000Z",
+        }),
+      ],
+    });
+
+    const feedUpdated = /<id>[^<]*<\/id>\s*<updated>([^<]+)<\/updated>/.exec(
+      xml,
+    )?.[1];
+    expect(feedUpdated).toBe("2026-05-09T00:00:00.000Z");
+  });
+
+  it("falls back to the render time for an empty feed", () => {
+    const xml = defaultFeedRenderer({
+      ...makeFeedData(makePostView()),
+      posts: [],
+    });
+
+    const feedUpdated = /<id>[^<]*<\/id>\s*<updated>([^<]+)<\/updated>/.exec(
+      xml,
+    )?.[1];
+    expect(feedUpdated).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+  });
+
   it("keeps Atom entry titles empty for untitled posts and strips script tags from content", () => {
     const xml = defaultFeedRenderer(
       makeFeedData(
@@ -110,6 +152,24 @@ describe("feed renderers", () => {
     expect(xml).not.toContain("<iframe");
   });
 
+  it("resolves relative links and media URLs inside post HTML", () => {
+    const post = makePostView({
+      bodyHtml:
+        '<p><a href="/related">Related</a> <a href="#footnote">Footnote</a></p>' +
+        '<img src="/media/inline.jpg" alt="Inline">' +
+        '<video poster="/media/poster.jpg"><source src="/media/clip.mp4"></video>' +
+        '<span data-src="/leave-this-relative"></span>',
+    });
+    const xml = defaultFeedRenderer(makeFeedData(post));
+
+    expect(xml).toContain('href="https://example.com/related"');
+    expect(xml).toContain('href="#footnote"');
+    expect(xml).toContain('src="https://example.com/media/inline.jpg"');
+    expect(xml).toContain('poster="https://example.com/media/poster.jpg"');
+    expect(xml).toContain('src="https://example.com/media/clip.mp4"');
+    expect(xml).toContain('data-src="/leave-this-relative"');
+  });
+
   it("does not expose quote attribution as feed title", () => {
     const xml = defaultFeedRenderer(
       makeFeedData(
@@ -158,6 +218,57 @@ describe("feed renderers", () => {
     );
   });
 
+  it("renders YouTube Link previews as a linked thumbnail with a provider-aware action", () => {
+    const post = makePostView({
+      format: "link",
+      title: "A useful video",
+      url: "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+      bodyHtml: "<p>My notes on the video.</p>",
+      previewKind: "video",
+      previewProvider: "youtube",
+      previewImageUrl: "/media/previews/youtube.jpg",
+    });
+    const xml = defaultFeedRenderer(makeFeedData(post));
+
+    expect(xml).toContain(
+      '<figure><a href="https://www.youtube.com/watch?v=dQw4w9WgXcQ"><img src="https://example.com/media/previews/youtube.jpg" alt="A useful video"/></a><figcaption><a href="https://www.youtube.com/watch?v=dQw4w9WgXcQ">▶ Watch on YouTube</a></figcaption></figure>',
+    );
+    expect(xml.indexOf("<figure>")).toBeLessThan(
+      xml.indexOf("My notes on the video."),
+    );
+    expect(xml).not.toContain("<iframe");
+    expect(xml).not.toContain('rel="enclosure"');
+  });
+
+  it("renders non-video Link previews without a video action", () => {
+    const post = makePostView({
+      format: "link",
+      title: "Illustrated article",
+      url: "https://external.com/illustrated",
+      previewKind: "image",
+      previewImageUrl: "https://example.com/previews/article.jpg",
+    });
+    const xml = defaultFeedRenderer(makeFeedData(post));
+
+    expect(xml).toContain(
+      '<figure><a href="https://external.com/illustrated"><img src="https://example.com/previews/article.jpg" alt="Illustrated article"/></a></figure>',
+    );
+    expect(xml).not.toContain("Watch video");
+    expect(xml).not.toContain("Watch on");
+  });
+
+  it("keeps the text fallback when a Link post has no preview image", () => {
+    const post = makePostView({
+      format: "link",
+      title: "Text-only link",
+      url: "https://external.com/text-only",
+    });
+    const xml = defaultFeedRenderer(makeFeedData(post));
+
+    expect(xml).toContain("<![CDATA[<p>Text-only link</p>");
+    expect(xml).not.toContain("<figure>");
+  });
+
   it("note posts still link to blog permalink without ★", () => {
     const post = makePostView({
       format: "note",
@@ -272,6 +383,38 @@ describe("feed renderers", () => {
     );
   });
 
+  it("renders a YouTube Link preview inside a thread reply", () => {
+    const reply = makePostView({
+      id: "reply-video",
+      permalink: "/reply-video",
+      slug: "reply-video",
+      format: "link",
+      title: "Thread video",
+      url: "https://youtu.be/dQw4w9WgXcQ",
+      previewKind: "video",
+      previewProvider: "youtube",
+      previewImageUrl: "/media/previews/thread-video.jpg",
+    });
+
+    const xml = defaultFeedRenderer(
+      makeFeedData(
+        makePostView({
+          title: "Thread Root",
+          bodyHtml: "<p>Root content</p>",
+          threadReplies: [reply],
+        }),
+      ),
+    );
+
+    const replyTitle =
+      '<h2><a href="https://youtu.be/dQw4w9WgXcQ">Thread video</a></h2>';
+    const preview =
+      '<figure><a href="https://youtu.be/dQw4w9WgXcQ"><img src="https://example.com/media/previews/thread-video.jpg" alt="Thread video"/></a><figcaption><a href="https://youtu.be/dQw4w9WgXcQ">▶ Watch on YouTube</a></figcaption></figure>';
+    expect(xml).toContain(replyTitle);
+    expect(xml).toContain(preview);
+    expect(xml.indexOf(replyTitle)).toBeLessThan(xml.indexOf(preview));
+  });
+
   it("includes thread reply media as Atom enclosures on the combined entry", () => {
     const reply = makePostView({
       id: "reply-1",
@@ -368,6 +511,31 @@ describe("feed renderers", () => {
     );
   });
 
+  it("resolves relative attachment, poster, and enclosure URLs", () => {
+    const post = makePostView({
+      media: [
+        makeMediaView({
+          id: "med_local_vid",
+          url: "/media/local-clip.mp4",
+          thumbnailUrl: "/media/local-clip-thumb.jpg",
+          posterUrl: "/media/local-clip-poster.jpg",
+          mimeType: "video/mp4",
+        }),
+      ],
+    });
+    const xml = defaultFeedRenderer(makeFeedData(post));
+
+    expect(xml).toContain(
+      '<a href="https://example.com/media/local-clip.mp4"><img src="https://example.com/media/local-clip-poster.jpg"',
+    );
+    expect(xml).toContain(
+      '<a href="https://example.com/media/local-clip.mp4">▶ Watch video</a>',
+    );
+    expect(xml).toContain(
+      '<link rel="enclosure" type="video/mp4" href="https://example.com/media/local-clip.mp4"',
+    );
+  });
+
   it("renders audio attachments as a labeled link with duration and size", () => {
     const post = makePostView({
       media: [

package/src/lib/__tests__/footnotes-upgrade.test.ts

@@ -0,0 +1,181 @@
+import type { JSONContent } from "@tiptap/core";
+import { describe, expect, it } from "vitest";
+import { upgradeLegacyFootnotes } from "../footnotes.js";
+import { markdownToTiptapJson } from "../markdown-to-tiptap.js";
+import { renderTiptapDocument } from "../tiptap-render.js";
+
+function linkedText(text: string, href: string): JSONContent {
+  return {
+    type: "text",
+    text,
+    marks: [
+      {
+        type: "link",
+        attrs: { href, target: "_blank", rel: "noopener noreferrer" },
+      },
+    ],
+  };
+}
+
+function legacyDocument(): JSONContent {
+  return {
+    type: "doc",
+    content: [
+      {
+        type: "paragraph",
+        content: [
+          { type: "text", text: "First" },
+          linkedText("[1]", "#fn-1"),
+          { type: "text", text: " and repeated" },
+          linkedText("[1]", "#fn-1"),
+          { type: "text", text: ". Second" },
+          linkedText("[2]", "#fn-2"),
+        ],
+      },
+      { type: "horizontalRule" },
+      {
+        type: "orderedList",
+        attrs: { start: 1, type: null },
+        content: [
+          {
+            type: "listItem",
+            content: [
+              {
+                type: "paragraph",
+                content: [
+                  { type: "text", text: "Rich definition with " },
+                  linkedText("source", "https://example.com"),
+                  linkedText("↩︎", "#fnref-1"),
+                ],
+              },
+              {
+                type: "bulletList",
+                content: [
+                  {
+                    type: "listItem",
+                    content: [
+                      {
+                        type: "paragraph",
+                        content: [{ type: "text", text: "Nested detail" }],
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            type: "listItem",
+            content: [
+              {
+                type: "paragraph",
+                content: [
+                  { type: "text", text: "Second definition" },
+                  linkedText("↩︎", "#fnref-2"),
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  };
+}
+
+describe("upgradeLegacyFootnotes", () => {
+  it("upgrades the historical link, rule, list, and backlink shape", () => {
+    const result = upgradeLegacyFootnotes(legacyDocument());
+
+    expect(result.upgraded).toBe(true);
+    expect(result.doc.content?.map((node) => node.type)).toEqual([
+      "paragraph",
+      "footnoteDefinition",
+      "footnoteDefinition",
+    ]);
+    expect(
+      result.doc.content?.[0]?.content?.filter(
+        (node) => node.type === "footnoteReference",
+      ),
+    ).toEqual([
+      { type: "footnoteReference", attrs: { label: "1" } },
+      { type: "footnoteReference", attrs: { label: "1" } },
+      { type: "footnoteReference", attrs: { label: "2" } },
+    ]);
+
+    const serialized = JSON.stringify(result.doc);
+    expect(serialized).not.toContain("#fn-");
+    expect(serialized).not.toContain("#fnref-");
+    expect(serialized).not.toContain("↩");
+    expect(serialized).toContain("https://example.com");
+    expect(serialized).toContain("Nested detail");
+
+    const html = renderTiptapDocument(result.doc, {
+      namespace: "pst_legacy",
+    });
+    expect(html).toContain('role="doc-noteref"');
+    expect(html).toContain('role="doc-endnotes"');
+    expect(html).toContain('role="doc-backlink"');
+    expect(html).not.toContain("<hr>");
+  });
+
+  it("is idempotent after the canonical nodes have been created", () => {
+    const first = upgradeLegacyFootnotes(legacyDocument());
+    const second = upgradeLegacyFootnotes(first.doc);
+
+    expect(second).toEqual({ doc: first.doc, upgraded: false });
+  });
+
+  it("upgrades the Markdown round-trip shape observed on historical posts", () => {
+    const body = markdownToTiptapJson(
+      [
+        "Codex[\\[1\\]](#fn-1) and Claude[\\[2\\]](#fn-2).",
+        "",
+        "---",
+        "",
+        "1. First definition.[↩︎](#fnref-1)",
+        "2. Second definition.[↩︎](#fnref-2)",
+      ].join("\n"),
+    );
+    const result = upgradeLegacyFootnotes(JSON.parse(body) as JSONContent);
+
+    expect(result.upgraded).toBe(true);
+    expect(JSON.stringify(result.doc)).toContain('"type":"footnoteReference"');
+    expect(JSON.stringify(result.doc)).toContain('"type":"footnoteDefinition"');
+  });
+
+  it.each([
+    {
+      name: "has no separator",
+      mutate(doc: JSONContent) {
+        doc.content?.splice(-2, 1);
+      },
+    },
+    {
+      name: "has an unmatched backlink",
+      mutate(doc: JSONContent) {
+        const list = doc.content?.at(-1);
+        const backlink = list?.content?.[0]?.content?.[0]?.content?.at(-1);
+        if (backlink?.marks?.[0]?.attrs) {
+          backlink.marks[0].attrs.href = "#fnref-99";
+        }
+      },
+    },
+    {
+      name: "has an ordinary numbered list",
+      mutate(doc: JSONContent) {
+        const list = doc.content?.at(-1);
+        const paragraph = list?.content?.[0]?.content?.[0];
+        paragraph?.content?.pop();
+      },
+    },
+  ])("leaves a document unchanged when it $name", ({ mutate }) => {
+    const doc = legacyDocument();
+    mutate(doc);
+    const original = globalThis.structuredClone(doc);
+
+    expect(upgradeLegacyFootnotes(doc)).toEqual({
+      doc: original,
+      upgraded: false,
+    });
+  });
+});

package/src/lib/__tests__/markdown-roundtrip-embed.test.ts

@@ -8,6 +8,8 @@ interface TiptapNode {
   type: string;
   attrs?: Record<string, unknown>;
   content?: TiptapNode[];
+  marks?: Array<{ type: string; attrs?: Record<string, unknown> }>;
+  text?: string;
 }
 
 function findNode(node: TiptapNode, type: string): TiptapNode | null {
@@ -86,3 +88,62 @@ describe("markdown round-trip: htmlBlock", () => {
     expect(out).toContain(inner);
   });
 });
+
+describe("markdown manager integration", () => {
+  it("round-trips ordered-list numbering and nested inline formatting", () => {
+    const markdown = [
+      "5. **Five**",
+      "6. Six",
+      "   1. *Nested one*",
+      "   2. Nested two",
+    ].join("\n");
+
+    const parsed = parseMarkdownDocument(markdown) as TiptapNode;
+    const outerList = findNode(parsed, "orderedList");
+    expect(outerList?.attrs?.start).toBe(5);
+    expect(outerList?.content).toHaveLength(2);
+    const nestedList = findNode(
+      outerList?.content?.[1] ?? parsed,
+      "orderedList",
+    );
+    expect(nestedList?.attrs?.start ?? 1).toBe(1);
+    expect(nestedList?.content).toHaveLength(2);
+
+    const serialized = serializeMarkdownDocument(parsed);
+    expect(serialized).toContain("5. **Five**");
+    expect(serialized).toContain("6. Six");
+    expect(parseMarkdownDocument(serialized)).toEqual(parsed);
+  });
+
+  it("round-trips table, image, link, and footnote integrations", () => {
+    const markdown = [
+      "[Source](https://example.com)",
+      "",
+      "| Name | Value |",
+      "| --- | --- |",
+      "| Jant | 1 |",
+      "",
+      '![Alt text](https://example.com/image.png "Title")',
+      "",
+      "Body[^note]",
+      "",
+      "[^note]: Footnote body",
+    ].join("\n");
+
+    const parsed = parseMarkdownDocument(markdown) as TiptapNode;
+    expect(findNode(parsed, "table")).not.toBeNull();
+    expect(findNode(parsed, "image")?.attrs).toMatchObject({
+      src: "https://example.com/image.png",
+      alt: "Alt text",
+      title: "Title",
+    });
+    expect(findNode(parsed, "footnoteReference")?.attrs?.label).toBe("note");
+    expect(findNode(parsed, "footnoteDefinition")?.attrs?.label).toBe("note");
+    const linkedText = findNode(parsed, "text");
+    expect(linkedText?.marks?.[0]?.type).toBe("link");
+    expect(linkedText?.marks?.[0]?.attrs?.href).toBe("https://example.com");
+
+    const serialized = serializeMarkdownDocument(parsed);
+    expect(parseMarkdownDocument(serialized)).toEqual(parsed);
+  });
+});

package/src/lib/__tests__/markdown-to-tiptap.test.ts

@@ -128,6 +128,29 @@ describe("markdownToTiptapJson", () => {
       expect(doc.content[1].content[0].type).toBe("paragraph");
       expect(doc.content[1].content[0].content[0].text).toBe("Footnote body");
     });
+
+    it("normalizes inline footnotes into paired structural nodes", () => {
+      const doc = parse("Body^[Inline **bold** note.]");
+
+      expect(doc.content[0].content).toEqual([
+        { type: "text", text: "Body" },
+        { type: "footnoteReference", attrs: { label: "1" } },
+      ]);
+      expect(doc.content[1]).toMatchObject({
+        type: "footnoteDefinition",
+        attrs: { label: "1" },
+        content: [
+          {
+            type: "paragraph",
+            content: [
+              { type: "text", text: "Inline " },
+              { type: "text", text: "bold", marks: [{ type: "bold" }] },
+              { type: "text", text: " note." },
+            ],
+          },
+        ],
+      });
+    });
   });
 
   describe("inline elements", () => {
@@ -398,15 +421,20 @@ describe("end-to-end: Markdown → markdownToTiptapJson → renderTiptapJson", (
     expect(html).toContain("<figcaption>Caption</figcaption>");
   });
 
-  it("renders footnotes as inline sidenotes through the shared document renderer", () => {
+  it("renders semantic footnotes through the shared document renderer", () => {
     const json = markdownToTiptapJson("Body[^1]\n\n[^1]: Footnote body");
     const html = renderTiptapJson(json);
 
+    expect(html).toContain('role="doc-noteref"');
     expect(html).toContain(
-      '<label for="sn-1" class="margin-toggle sidenote-number footref">',
+      '<section class="footnote-endnotes" role="doc-endnotes">',
     );
-    expect(html).toContain('<span class="sidenote">Footnote body</span>');
-    expect(html).not.toContain('<section class="footnotes"');
+    expect(html).toContain('<ol class="footnote-list">');
+    expect(html).toContain('<li id="fn-1" class="footnote">');
+    expect(html).toMatch(/<p>Footnote body <span class="footnote-backlinks">/);
+    expect(html).toContain('role="doc-backlink"');
+    expect(html).not.toMatch(/footnote-document|footnote-main|footnote-body/);
+    expect(html).not.toMatch(/data-footnote-|--footnote-|tabindex=/);
   });
 
   it("renders a complex document", () => {

package/src/lib/__tests__/markdown.test.ts

@@ -26,6 +26,22 @@ describe("render", () => {
     expect(html).toContain(">link</a>");
   });
 
+  it("renders phone and messaging action links", () => {
+    expect(render("[Call](tel:+15551234567)")).toContain(
+      'href="tel:+15551234567"',
+    );
+    expect(render("[Message](sms:xxxxx@xx.com)")).toContain(
+      'href="sms:xxxxx@xx.com"',
+    );
+  });
+
+  it("strips executable link destinations", () => {
+    const html = render("[unsafe](javascript:alert(1))");
+
+    expect(html).not.toContain("javascript:");
+    expect(html).toContain('href=""');
+  });
+
   it("renders code blocks", () => {
     const html = render("```\nconst x = 1;\n```");
     expect(html).toContain("<code>");
@@ -62,14 +78,16 @@ describe("render", () => {
     expect(html).toBe("<p>Intro</p><!--more--><p>Rest</p>");
   });
 
-  it("renders footnote references as inline sidenotes", () => {
+  it("renders semantic footnote references and definitions", () => {
     const html = render("Body copy[^1]\n\n[^1]: Footnote body");
 
-    expect(html).toContain(
-      '<label for="sn-1" class="margin-toggle sidenote-number footref">',
-    );
-    expect(html).toContain('<span class="sidenote">Footnote body</span>');
-    expect(html).not.toContain('<section class="footnotes"');
+    expect(html).toContain('role="doc-noteref"');
+    expect(html).toContain('role="doc-endnotes"');
+    expect(html).toContain('class="footnote-list"');
+    expect(html).toContain("Footnote body");
+    expect(html).toContain('role="doc-backlink"');
+    expect(html.match(/<ol class="footnote-list">/g)).toHaveLength(1);
+    expect(html).not.toMatch(/footnote-document|data-footnote-|--footnote-/);
   });
 
   it("escapes raw HTML outside the supported markdown schema", () => {

package/src/lib/__tests__/navigation.test.ts

@@ -7,6 +7,7 @@ describe("getNavigationData", () => {
     const context = {
       var: {
         publicPath: "/",
+        currentSite: { id: "sit_navigation" },
         appConfig: {
           siteName: "Jant",
           sitePathPrefix: "",
@@ -34,8 +35,9 @@ describe("getNavigationData", () => {
 
     expect(result.isAuthenticated).toBe(false);
     expect(result.collections).toEqual([]);
-    expect(result.siteFooterHtml).toContain('<label for="sn-');
-    expect(result.siteFooterHtml).toContain('<span class="sidenote">');
+    expect(result.siteFooterHtml).toContain('role="doc-noteref"');
+    expect(result.siteFooterHtml).toContain('role="doc-endnotes"');
+    expect(result.siteFooterHtml).toContain("fn-2wpij13sz70fe-1");
     expect(result.siteFooterHtml).toContain("<strong>note</strong>");
     expect(result.siteFooterHtml).toContain(
       "&lt;script&gt;alert(1)&lt;/script&gt;",
@@ -96,4 +98,59 @@ describe("getNavigationData", () => {
     expect(result.links[0]?.url).toBe("/featured");
     expect(result.links[1]?.url).toBe("/");
   });
+
+  it("hides only the built-in RSS item when feeds are disabled", async () => {
+    const context = {
+      var: {
+        publicPath: "/",
+        appConfig: {
+          siteName: "Jant",
+          sitePathPrefix: "",
+          siteOrigin: "https://example.com",
+          siteDescription: "",
+          siteDescriptionExplicit: false,
+          siteAvatarUrl: "",
+          showHeaderAvatar: false,
+          siteFooter: "",
+          rssFeedsEnabled: false,
+        },
+        services: {
+          navItems: {
+            list: async () => [
+              {
+                id: "nav_rss",
+                type: "system",
+                systemKey: "rss",
+                label: "Feed",
+                url: "/feed",
+                placement: "header",
+                position: "a0",
+                createdAt: 1,
+                updatedAt: 1,
+              },
+              {
+                id: "nav_custom",
+                type: "link",
+                label: "Custom feed link",
+                url: "/feed",
+                placement: "header",
+                position: "a1",
+                createdAt: 1,
+                updatedAt: 1,
+              },
+            ],
+          },
+          collections: {
+            listByRecentActivity: async () => [],
+          },
+        },
+        isAuthenticated: false,
+        session: null,
+      },
+    } as unknown as Context;
+
+    const result = await getNavigationData(context);
+
+    expect(result.links.map((link) => link.id)).toEqual(["nav_custom"]);
+  });
 });