@jant/core 0.6.14 → 0.6.15

package/src/lib/__tests__/tiptap-render.test.ts

@@ -1,7 +1,9 @@
 import { describe, expect, it } from "vitest";
 import {
   renderTiptapDocument,
+  renderTiptapDocumentAroundBoundary,
   renderTiptapJson,
+  tryRenderTiptapJson,
   trimTiptapBody,
 } from "../tiptap-render.js";
 
@@ -68,7 +70,7 @@ describe("renderTiptapDocument", () => {
     );
   });
 
-  it("renders footnote references as inline sidenotes", () => {
+  it("renders canonical semantic endnotes without layout wrappers", () => {
     const html = renderTiptapDocument(
       doc(
         p(text("Body copy"), {
@@ -81,16 +83,21 @@ describe("renderTiptapDocument", () => {
           content: [p(text("Footnote body"))],
         },
       ),
+      { namespace: "pst_test" },
     );
 
     expect(html).toBe(
-      '<p>Body copy<label for="sn-1" class="margin-toggle sidenote-number footref"></label>' +
-        '<input type="checkbox" id="sn-1" class="margin-toggle footref-toggle"/>' +
-        '<span class="sidenote">Footnote body</span></p>',
+      '<p>Body copy<sup class="footnote-ref">' +
+        '<a id="fnref-0sk9zhgh1dhm5-1-1" href="#fn-0sk9zhgh1dhm5-1" role="doc-noteref">1</a></sup></p>' +
+        '<section class="footnote-endnotes" role="doc-endnotes"><ol class="footnote-list">' +
+        '<li id="fn-0sk9zhgh1dhm5-1" class="footnote"><p>Footnote body <span class="footnote-backlinks">' +
+        '<a href="#fnref-0sk9zhgh1dhm5-1-1" class="footnote-backref" role="doc-backlink">↩︎</a>' +
+        "</span></p></li></ol></section>",
     );
+    expect(html).not.toMatch(/<div|\sstyle=|\sdata-footnote-/);
   });
 
-  it("renders footnote reference without definition gracefully", () => {
+  it("renders a missing footnote definition without a dead link", () => {
     const html = renderTiptapDocument(
       doc(
         p(text("Body copy"), {
@@ -100,11 +107,255 @@ describe("renderTiptapDocument", () => {
       ),
     );
 
-    expect(html).toBe(
-      '<p>Body copy<label for="sn-1" class="margin-toggle sidenote-number footref"></label>' +
-        '<input type="checkbox" id="sn-1" class="margin-toggle footref-toggle"/>' +
-        '<span class="sidenote"></span></p>',
+    expect(html).toBe('<p>Body copy<sup class="footnote-ref">1</sup></p>');
+  });
+
+  it("uses a native list start when a missing definition creates a leading numbering gap", () => {
+    const html = renderTiptapDocument(
+      doc(
+        p(text("Missing"), {
+          type: "footnoteReference",
+          attrs: { label: "missing" },
+        }),
+        p(text("Defined"), {
+          type: "footnoteReference",
+          attrs: { label: "defined" },
+        }),
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "defined" },
+          content: [p(text("Second definition"))],
+        },
+      ),
     );
+
+    expect(html).toContain('<sup class="footnote-ref">1</sup>');
+    expect(html).toContain('href="#fn-2" role="doc-noteref">2</a>');
+    expect(html).toContain('<ol class="footnote-list" start="2">');
+    expect(html).toContain('<li id="fn-2" class="footnote">');
+    expect(html).not.toContain('value="2"');
+  });
+
+  it("uses a native list-item value only for an internal numbering gap", () => {
+    const html = renderTiptapDocument(
+      doc(
+        p({ type: "footnoteReference", attrs: { label: "one" } }),
+        p({ type: "footnoteReference", attrs: { label: "missing" } }),
+        p({ type: "footnoteReference", attrs: { label: "three" } }),
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "one" },
+          content: [p(text("First definition"))],
+        },
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "three" },
+          content: [p(text("Third definition"))],
+        },
+      ),
+    );
+
+    expect(html).toContain('<ol class="footnote-list">');
+    expect(html).toContain('<li id="fn-1" class="footnote">');
+    expect(html).toContain('<li id="fn-3" class="footnote" value="3">');
+  });
+
+  it("renders repeated references once with unique reciprocal backlinks", () => {
+    const html = renderTiptapDocument(
+      doc(
+        p(text("First"), {
+          type: "footnoteReference",
+          attrs: { label: "Note" },
+        }),
+        p(text("Second"), {
+          type: "footnoteReference",
+          attrs: { label: "note" },
+        }),
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "NOTE" },
+          content: [p(text("Shared definition"))],
+        },
+      ),
+      { namespace: "pst_repeat" },
+    );
+
+    expect(html.match(/role="doc-endnotes"/g)).toHaveLength(1);
+    expect(html.match(/<ol class="footnote-list">/g)).toHaveLength(1);
+    expect(html.match(/<li id="fn-/g)).toHaveLength(1);
+    expect(html).toContain('id="fnref-0r3u815ai35bm-1-1"');
+    expect(html).toContain('id="fnref-0r3u815ai35bm-1-2"');
+    expect(html.match(/href="#fn-0r3u815ai35bm-1"/g)).toHaveLength(2);
+    expect(html).toContain(
+      'href="#fnref-0r3u815ai35bm-1-1" class="footnote-backref" role="doc-backlink">↩︎1</a>',
+    );
+    expect(html).toContain(
+      'href="#fnref-0r3u815ai35bm-1-2" class="footnote-backref" role="doc-backlink">↩︎2</a>',
+    );
+    expect(html.indexOf("Shared definition")).toBeGreaterThan(
+      html.indexOf("Second"),
+    );
+  });
+
+  it("keeps all definitions in one native ordered list", () => {
+    const html = renderTiptapDocument(
+      doc(
+        p(text("First"), {
+          type: "footnoteReference",
+          attrs: { label: "first" },
+        }),
+        p(text("Second"), {
+          type: "footnoteReference",
+          attrs: { label: "second" },
+        }),
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "first" },
+          content: [p(text("First definition"))],
+        },
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "second" },
+          content: [p(text("Second definition"))],
+        },
+      ),
+    );
+
+    expect(html.match(/<ol class="footnote-list">/g)).toHaveLength(1);
+    expect(html).toContain('<li id="fn-1" class="footnote">');
+    expect(html).toContain('<li id="fn-2" class="footnote">');
+    expect(html).not.toMatch(/\s(?:start|value|style)=/);
+    expect(html.indexOf("First definition")).toBeGreaterThan(
+      html.indexOf("Second"),
+    );
+  });
+
+  it("keeps rich footnote blocks inside a native endnote list item", () => {
+    const html = renderTiptapDocument(
+      doc(
+        p(text("Body"), {
+          type: "footnoteReference",
+          attrs: { label: "rich" },
+        }),
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "rich" },
+          content: [
+            p(text("First paragraph")),
+            {
+              type: "bulletList",
+              content: [
+                {
+                  type: "listItem",
+                  content: [p(text("List item"))],
+                },
+              ],
+            },
+          ],
+        },
+      ),
+    );
+
+    expect(html).toContain(
+      '<section class="footnote-endnotes" role="doc-endnotes"><ol class="footnote-list"',
+    );
+    expect(html).toContain('<li id="fn-1" class="footnote">');
+    expect(html).toContain(
+      '<p>First paragraph</p><ul><li><p>List item</p></li></ul><p class="footnote-backlinks"><a href="#fnref-1-1" class="footnote-backref" role="doc-backlink">↩︎</a></p>',
+    );
+    expect(html).not.toContain('<div class="footnote-body"');
+    expect(html).not.toContain('role="doc-footnote"');
+  });
+
+  it("appends backlinks to the authored final paragraph of rich definitions", () => {
+    const html = renderTiptapDocument(
+      doc(p({ type: "footnoteReference", attrs: { label: "rich" } }), {
+        type: "footnoteDefinition",
+        attrs: { label: "rich" },
+        content: [
+          {
+            type: "bulletList",
+            content: [
+              {
+                type: "listItem",
+                content: [p(text("List item"))],
+              },
+            ],
+          },
+          p(text("Final paragraph")),
+        ],
+      }),
+    );
+
+    expect(html).toContain(
+      '<ul><li><p>List item</p></li></ul><p>Final paragraph <span class="footnote-backlinks">',
+    );
+    expect(html).not.toContain('<p class="footnote-backlinks">');
+  });
+
+  it("uses the render namespace to isolate documents sharing a page", () => {
+    const input = doc(p({ type: "footnoteReference", attrs: { label: "1" } }), {
+      type: "footnoteDefinition",
+      attrs: { label: "1" },
+      content: [p(text("Definition"))],
+    });
+
+    const first = renderTiptapDocument(input, { namespace: "pst_first" });
+    const second = renderTiptapDocument(input, { namespace: "pst_second" });
+
+    expect(first).toContain('id="fn-3t66v0e9xc2qx-1"');
+    expect(second).toContain('id="fn-2b338ib1g2med-1"');
+    expect(first).not.toContain("2b338ib1g2med");
+    expect(second).not.toContain("3t66v0e9xc2qx");
+  });
+
+  it("keeps immutable entity namespaces compact in public fragment IDs", () => {
+    const input = doc(p({ type: "footnoteReference", attrs: { label: "1" } }), {
+      type: "footnoteDefinition",
+      attrs: { label: "1" },
+      content: [p(text("Definition"))],
+    });
+    const namespace = "pst_01kxwe4tkwfqfsrwcgqgeg1b7k";
+    const html = renderTiptapDocument(input, { namespace });
+    const referenceId = html.match(/<a id="([^"]+)"/)?.[1];
+    const definitionId = html.match(/<li id="([^"]+)"/)?.[1];
+
+    expect(referenceId).toBe("fnref-0nj7nw33xdf9h-1-1");
+    expect(definitionId).toBe("fn-0nj7nw33xdf9h-1");
+    expect(referenceId?.length).toBeLessThan(30);
+    expect(html).not.toContain(namespace);
+    expect(html).toContain(`href="#${definitionId}"`);
+    expect(html).toContain(`href="#${referenceId}"`);
+  });
+
+  it("splits at a source boundary using the full repeated-footnote plan", () => {
+    const input = doc(
+      p(text("First"), {
+        type: "footnoteReference",
+        attrs: { label: "shared" },
+      }),
+      p(text("Second"), {
+        type: "footnoteReference",
+        attrs: { label: "shared" },
+      }),
+      {
+        type: "footnoteDefinition",
+        attrs: { label: "shared" },
+        content: [p(text("Definition"))],
+      },
+    );
+    const options = { namespace: "pst_split" };
+    const full = renderTiptapDocument(input, options);
+    const split = renderTiptapDocumentAroundBoundary(input, 1, options);
+
+    expect(split).not.toBeNull();
+    expect(split!.beforeHtml + split!.afterHtml).toBe(full);
+    expect(split!.beforeHtml).toContain("fnref-2q7yplng9am9n-1-1");
+    expect(split!.beforeHtml).not.toContain("footnote-document");
+    expect(split!.beforeHtml).not.toContain('role="doc-endnotes"');
+    expect(split!.afterHtml).toContain('id="fnref-2q7yplng9am9n-1-2"');
+    expect(split!.afterHtml).toContain('role="doc-endnotes"');
+    expect(split!.afterHtml.endsWith("</section>")).toBe(true);
   });
 
   it("renders code blocks as escaped text, not nested inline markup", () => {
@@ -141,6 +392,14 @@ describe("renderTiptapJson", () => {
   it("returns an empty string for non-doc JSON", () => {
     expect(renderTiptapDocument({ type: "paragraph" })).toBe("");
   });
+
+  it("distinguishes invalid JSON from a valid empty document", () => {
+    expect(tryRenderTiptapJson("not json")).toMatchObject({ ok: false });
+    expect(tryRenderTiptapJson(JSON.stringify(doc()))).toEqual({
+      ok: true,
+      html: "",
+    });
+  });
 });
 
 describe("trimTiptapBody", () => {

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

@@ -402,6 +402,12 @@ describe("tiptapJsonToMarkdown", () => {
       const md = "Body copy[^1]\n\n[^1]: Footnote body";
       expect(roundtrip(md)).toBe(md);
     });
+
+    it("canonicalizes inline footnotes as references plus definitions", () => {
+      expect(roundtrip("Body^[Inline **bold** note.]")).toBe(
+        "Body[^1]\n\n[^1]: Inline **bold** note.",
+      );
+    });
   });
 
   describe("edge cases", () => {

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

@@ -20,6 +20,7 @@ import type {
   SearchResult,
   Post,
 } from "../../types.js";
+import { renderTiptapJson } from "../tiptap-render.js";
 const EMPTY_CTX: MediaContext = {};
 const CTX_WITH_URLS: MediaContext = {
   r2PublicUrl: "https://cdn.example.com",
@@ -271,6 +272,58 @@ describe("toPostView", () => {
     );
   });
 
+  it("places the summary boundary after a footnote repeated in the hidden tail", () => {
+    const firstText = "A".repeat(300);
+    const secondText = "B".repeat(300);
+    const body = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [
+            { type: "text", text: firstText },
+            { type: "footnoteReference", attrs: { label: "shared" } },
+          ],
+        },
+        {
+          type: "paragraph",
+          content: [
+            { type: "text", text: secondText },
+            { type: "footnoteReference", attrs: { label: "shared" } },
+          ],
+        },
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "shared" },
+          content: [
+            {
+              type: "paragraph",
+              content: [{ type: "text", text: "Shared definition" }],
+            },
+          ],
+        },
+      ],
+    });
+    const bodyHtml = renderTiptapJson(body, { namespace: UUID_1 });
+    const view = toPostView(
+      makePostWithMedia({ title: "Article", body, bodyHtml }),
+      EMPTY_CTX,
+    );
+
+    expect(view.summaryHasMore).toBe(true);
+    const markerIndex = view.bodyHtml?.indexOf('<span id="continue"></span>');
+    expect(markerIndex).toBeGreaterThan(
+      view.bodyHtml?.indexOf(firstText) ?? -1,
+    );
+    expect(markerIndex).toBeLessThan(view.bodyHtml?.indexOf(secondText) ?? -1);
+    expect(view.bodyHtml).toContain('href="#fnref-1jp3895hp1ag7-1-2"');
+    expect(view.bodyHtml).not.toContain("footnote-document");
+    expect(view.bodyHtml?.match(/<ol class="footnote-list">/g)).toHaveLength(1);
+    expect(view.bodyHtml?.indexOf("Shared definition")).toBeGreaterThan(
+      view.bodyHtml?.indexOf(secondText) ?? -1,
+    );
+  });
+
   it("does not attach summaryHtml for short untitled notes", () => {
     const body = JSON.stringify({
       type: "doc",

package/src/lib/__tests__/worker-response-cache.test.ts

@@ -1,6 +1,10 @@
 import { describe, expect, it } from "vitest";
 import type { Bindings } from "../../types.js";
-import { withWorkerResponseCache } from "../worker-response-cache.js";
+import { POST_BODY_HTML_VERSION } from "../post-body-html.js";
+import {
+  normalizeWorkerCacheKeyUrl,
+  withWorkerResponseCache,
+} from "../worker-response-cache.js";
 
 interface StoredResponse {
   body: Uint8Array;
@@ -59,6 +63,19 @@ function createCloudflareBindings(overrides: Partial<Bindings> = {}): Bindings {
 }
 
 describe("withWorkerResponseCache", () => {
+  it("versions cache keys with the current body HTML contract", () => {
+    const url = new URL(
+      normalizeWorkerCacheKeyUrl(
+        "https://example.com/feed?__jant_body_html=old&utm_source=test",
+      ),
+    );
+
+    expect(url.searchParams.get("__jant_body_html")).toBe(
+      String(POST_BODY_HTML_VERSION),
+    );
+    expect(url.searchParams.has("utm_source")).toBe(false);
+  });
+
   it("caches anonymous phase-one feed responses and normalizes tracking params", async () => {
     const cache = createMemoryCache();
     const bindings = createCloudflareBindings();