@jant/core 0.6.14 → 0.6.16

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

@@ -18,7 +18,7 @@ import { createPostService } from "../../services/post.js";
 import { createMediaService } from "../../services/media.js";
 import { createPathService } from "../../services/path.js";
 import { createCollectionService } from "../../services/collection.js";
-import { postCollections, posts as postTable, sites } from "../../db/schema.js";
+import { posts as postTable, sites } from "../../db/schema.js";
 import { buildMediaMap } from "../media-helpers.js";
 import {
   assembleCollectionTimeline,
@@ -157,18 +157,14 @@ describe("Timeline data assembly", () => {
         return {
           post: postWithMedia,
           threadPreview: {
-            secondReply: threadCtx.secondReply
-              ? {
-                  ...threadCtx.secondReply,
-                  mediaAttachments: [],
-                }
-              : undefined,
-            penultimateReply: threadCtx.penultimateReply
-              ? {
-                  ...threadCtx.penultimateReply,
-                  mediaAttachments: [],
-                }
-              : undefined,
+            leadingReplies: threadCtx.leadingReplies.map((reply) => ({
+              ...reply,
+              mediaAttachments: [],
+            })),
+            trailingReplies: threadCtx.trailingReplies.map((reply) => ({
+              ...reply,
+              mediaAttachments: [],
+            })),
             latestReply: {
               ...threadCtx.latestReply,
               mediaAttachments: [],
@@ -183,7 +179,9 @@ describe("Timeline data assembly", () => {
 
     expect(items).toHaveLength(1);
     expect(items[0]?.threadPreview).toBeDefined();
-    expect(items[0]?.threadPreview?.secondReply?.bodyText).toBe("Reply 1");
+    expect(items[0]?.threadPreview?.leadingReplies[0]?.bodyText).toBe(
+      "Reply 1",
+    );
     expect(items[0]?.threadPreview?.latestReply.bodyText).toBe("Reply 2");
     expect(items[0]?.threadPreview?.totalReplyCount).toBe(2);
   });
@@ -347,6 +345,7 @@ describe("Timeline data assembly", () => {
 
     expect(result.items).toHaveLength(1);
     expect(result.items[0]?.post.id).toBe(root.id);
+    expect(result.items[0]?.curatedThread?.showContextRatings).toBe(false);
     expect(result.items[0]?.curatedThread?.segments).toEqual([
       expect.objectContaining({
         post: expect.objectContaining({ id: root.id }),
@@ -526,22 +525,26 @@ describe("Timeline data assembly", () => {
     ]);
   });
 
-  it("orders featured threads by latest featured time instead of later non-featured activity", async () => {
+  it("orders Featured Threads by the latest selected Post publication time", async () => {
     const olderFeaturedRoot = await postService.create({
       format: "note",
       bodyMarkdown: "Older featured root",
+      publishedAt: 1000,
     });
     const olderFeaturedReply = await postService.create({
       format: "note",
       bodyMarkdown: "Older featured reply",
       replyToId: olderFeaturedRoot.id,
+      publishedAt: 3000,
     });
     const newerFeaturedRoot = await postService.create({
       format: "note",
       bodyMarkdown: "Newer featured root",
       featured: true,
+      publishedAt: 2000,
     });
 
+    // Featured timestamps deliberately disagree with publication order.
     await db
       .update(postTable)
       .set({ featuredAt: 100 })
@@ -555,6 +558,7 @@ describe("Timeline data assembly", () => {
       format: "note",
       bodyMarkdown: "Later non-featured reply",
       replyToId: olderFeaturedReply.id,
+      publishedAt: 4000,
     });
 
     const result = await assembleFeaturedTimeline(createTimelineContext(), {
@@ -562,11 +566,63 @@ describe("Timeline data assembly", () => {
     });
 
     expect(result.items).toHaveLength(2);
-    expect(result.items[0]?.post.id).toBe(newerFeaturedRoot.id);
-    expect(result.items[1]?.post.id).toBe(olderFeaturedRoot.id);
+    expect(result.items[0]?.post.id).toBe(olderFeaturedRoot.id);
+    expect(result.items[1]?.post.id).toBe(newerFeaturedRoot.id);
+  });
+
+  it("loads only the Root, Featured Posts, and final Post for curated display", async () => {
+    const root = await postService.create({
+      format: "note",
+      bodyMarkdown: "Root",
+      publishedAt: 1000,
+    });
+    const hiddenReplyA = await postService.create({
+      format: "note",
+      bodyMarkdown: "Hidden reply A",
+      replyToId: root.id,
+      publishedAt: 2000,
+    });
+    const featuredReply = await postService.create({
+      format: "note",
+      bodyMarkdown: "Featured reply",
+      replyToId: hiddenReplyA.id,
+      featured: true,
+      publishedAt: 3000,
+    });
+    const hiddenReplyB = await postService.create({
+      format: "note",
+      bodyMarkdown: "Hidden reply B",
+      replyToId: featuredReply.id,
+      publishedAt: 4000,
+    });
+    const finalReply = await postService.create({
+      format: "note",
+      bodyMarkdown: "Final reply",
+      replyToId: hiddenReplyB.id,
+      publishedAt: 5000,
+    });
+
+    const result = await postService.getFeaturedThreadTimelineData([root.id]);
+    const thread = result.get(root.id);
+
+    expect(thread?.posts).toEqual([
+      expect.objectContaining({
+        post: expect.objectContaining({ id: root.id }),
+        position: 0,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: featuredReply.id }),
+        position: 2,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: finalReply.id }),
+        position: 4,
+      }),
+    ]);
+    expect(thread?.featuredPostIds).toEqual([featuredReply.id]);
   });
 
-  it("groups collection posts by root thread and sorts threads by collected-at", async () => {
+  it("renders every post in each collected Thread and sorts by Thread activity", async () => {
     const collection = await collectionService.create({
       slug: "reading",
       title: "Reading",
@@ -595,26 +651,12 @@ describe("Timeline data assembly", () => {
       bodyMarkdown: "Second thread root",
     });
 
-    await db.insert(postCollections).values([
-      {
-        siteId: DEFAULT_TEST_SITE_ID,
-        postId: collectedReplyA.id,
-        collectionId: collection.id,
-        createdAt: 100,
-      },
-      {
-        siteId: DEFAULT_TEST_SITE_ID,
-        postId: collectedReplyB.id,
-        collectionId: collection.id,
-        createdAt: 200,
-      },
-      {
-        siteId: DEFAULT_TEST_SITE_ID,
-        postId: secondRoot.id,
-        collectionId: collection.id,
-        createdAt: 300,
-      },
-    ]);
+    await collectionService.addThread(collection.id, firstRoot.id, {
+      createdAt: 200,
+    });
+    await collectionService.addThread(collection.id, secondRoot.id, {
+      createdAt: 300,
+    });
 
     const result = await assembleCollectionTimeline(createTimelineContext(), {
       collectionIds: [collection.id],
@@ -625,6 +667,7 @@ describe("Timeline data assembly", () => {
     expect(result.items).toHaveLength(2);
     expect(result.items[0]?.post.id).toBe(secondRoot.id);
     expect(result.items[1]?.post.id).toBe(firstRoot.id);
+    expect(result.items[1]?.curatedThread?.showContextRatings).toBe(true);
     expect(result.items[1]?.curatedThread?.segments).toEqual([
       expect.objectContaining({
         post: expect.objectContaining({ id: firstRoot.id }),
@@ -634,17 +677,22 @@ describe("Timeline data assembly", () => {
       expect.objectContaining({
         post: expect.objectContaining({ id: collectedReplyA.id }),
         hiddenBeforeCount: 0,
-        highlighted: true,
+        highlighted: false,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: hiddenMiddleReply.id }),
+        hiddenBeforeCount: 0,
+        highlighted: false,
       }),
       expect.objectContaining({
         post: expect.objectContaining({ id: collectedReplyB.id }),
-        hiddenBeforeCount: 1,
+        hiddenBeforeCount: 0,
         highlighted: true,
       }),
     ]);
   });
 
-  it("keeps the last post visible when a collected root is the only selected post", async () => {
+  it("renders the complete Thread and highlights its latest Post", async () => {
     const collection = await collectionService.create({
       slug: "root-only",
       title: "Root only",
@@ -659,10 +707,7 @@ describe("Timeline data assembly", () => {
       replyToId: root.id,
     });
 
-    await db.insert(postCollections).values({
-      siteId: DEFAULT_TEST_SITE_ID,
-      postId: root.id,
-      collectionId: collection.id,
+    await collectionService.addThread(collection.id, root.id, {
       createdAt: 100,
     });
 
@@ -678,17 +723,17 @@ describe("Timeline data assembly", () => {
       expect.objectContaining({
         post: expect.objectContaining({ id: root.id }),
         hiddenBeforeCount: 0,
-        highlighted: true,
+        highlighted: false,
       }),
       expect.objectContaining({
         post: expect.objectContaining({ id: uncollectedReply.id }),
         hiddenBeforeCount: 0,
-        highlighted: false,
+        highlighted: true,
       }),
     ]);
   });
 
-  it("highlights the union of collected posts across multiple collections", async () => {
+  it("deduplicates Threads selected through multiple collections", async () => {
     const smart = await collectionService.create({
       slug: "smart",
       title: "Smart",
@@ -721,26 +766,15 @@ describe("Timeline data assembly", () => {
       bodyMarkdown: "Second thread root",
     });
 
-    await db.insert(postCollections).values([
-      {
-        siteId: DEFAULT_TEST_SITE_ID,
-        postId: smartReply.id,
-        collectionId: smart.id,
-        createdAt: 100,
-      },
-      {
-        siteId: DEFAULT_TEST_SITE_ID,
-        postId: movieReply.id,
-        collectionId: movies.id,
-        createdAt: 200,
-      },
-      {
-        siteId: DEFAULT_TEST_SITE_ID,
-        postId: secondRoot.id,
-        collectionId: movies.id,
-        createdAt: 300,
-      },
-    ]);
+    await collectionService.addThread(smart.id, firstRoot.id, {
+      createdAt: 100,
+    });
+    await collectionService.addThread(movies.id, firstRoot.id, {
+      createdAt: 200,
+    });
+    await collectionService.addThread(movies.id, secondRoot.id, {
+      createdAt: 300,
+    });
 
     const result = await assembleCollectionTimeline(createTimelineContext(), {
       collectionIds: [smart.id, movies.id],
@@ -760,11 +794,16 @@ describe("Timeline data assembly", () => {
       expect.objectContaining({
         post: expect.objectContaining({ id: smartReply.id }),
         hiddenBeforeCount: 0,
-        highlighted: true,
+        highlighted: false,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: hiddenMiddleReply.id }),
+        hiddenBeforeCount: 0,
+        highlighted: false,
       }),
       expect.objectContaining({
         post: expect.objectContaining({ id: movieReply.id }),
-        hiddenBeforeCount: 1,
+        hiddenBeforeCount: 0,
         highlighted: true,
       }),
     ]);

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

@@ -1,6 +1,7 @@
 import { describe, it, expect } from "vitest";
 import {
   TIMEZONES,
+  getTimeZoneOptions,
   isSupportedTimeZone,
   mapIanaToTimezone,
   normalizeTimeZone,
@@ -69,8 +70,15 @@ describe("normalizeTimeZone", () => {
     expect(normalizeTimeZone("London")).toBe("Europe/London");
   });
 
-  it("normalizes accepted IANA aliases to the curated canonical value", () => {
-    expect(normalizeTimeZone("Asia/Calcutta")).toBe("Asia/Kolkata");
+  it("preserves runtime-supported zones instead of collapsing their rules", () => {
+    expect(normalizeTimeZone("America/Phoenix")).toBe("America/Phoenix");
+    expect(normalizeTimeZone("Australia/Darwin")).toBe("Australia/Darwin");
+    expect(normalizeTimeZone("Etc/GMT-8")).toBe("Etc/GMT-8");
+  });
+
+  it("normalizes fixed offsets and UTC aliases through Intl", () => {
+    expect(normalizeTimeZone("+08")).toBe("+08:00");
+    expect(normalizeTimeZone("+08:00")).toBe("+08:00");
     expect(normalizeTimeZone("Etc/UTC")).toBe("UTC");
   });
 
@@ -81,9 +89,13 @@ describe("normalizeTimeZone", () => {
 });
 
 describe("isSupportedTimeZone", () => {
-  it("accepts canonical, aliased, and legacy values", () => {
+  it("accepts runtime zones, fixed offsets, and legacy values", () => {
     expect(isSupportedTimeZone("Asia/Shanghai")).toBe(true);
     expect(isSupportedTimeZone("Asia/Calcutta")).toBe(true);
+    expect(isSupportedTimeZone("America/Phoenix")).toBe(true);
+    expect(isSupportedTimeZone("Australia/Darwin")).toBe(true);
+    expect(isSupportedTimeZone("Etc/GMT-8")).toBe(true);
+    expect(isSupportedTimeZone("+08:00")).toBe(true);
     expect(isSupportedTimeZone("Beijing")).toBe(true);
   });
 
@@ -92,3 +104,19 @@ describe("isSupportedTimeZone", () => {
     expect(isSupportedTimeZone("Unknown/Zone")).toBe(false);
   });
 });
+
+describe("getTimeZoneOptions", () => {
+  it("adds an unlisted current timezone without expanding the curated list", () => {
+    const options = getTimeZoneOptions("America/Phoenix");
+
+    expect(options).toHaveLength(TIMEZONES.length + 1);
+    expect(options.at(-1)).toMatchObject({
+      label: "America/Phoenix",
+      value: "America/Phoenix",
+    });
+  });
+
+  it("does not duplicate a curated timezone", () => {
+    expect(getTimeZoneOptions("Asia/Shanghai")).toBe(TIMEZONES);
+  });
+});

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", () => {