@jant/core 0.6.14 → 0.6.15

package/src/lib/__tests__/resolve-config.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { resolveConfig } from "../resolve-config.js";
+import { resolveConfig, resolveSummaryConfig } from "../resolve-config.js";
 import type { Bindings } from "../../types/bindings.js";
 
 function makeEnv(overrides: Partial<Bindings> = {}): Bindings {
@@ -28,11 +28,14 @@ describe("resolveConfig", () => {
     expect(config.timeZone).toBe("UTC");
     expect(config.showJantBrandingOnHome).toBe(false);
     expect(config.noindex).toBe(false);
+    expect(config.publicApiEnabled).toBe(true);
+    expect(config.rssFeedsEnabled).toBe(true);
     expect(config.demoMode).toBe(false);
     expect(config.pageSize).toBe(50);
     expect(config.searchPageSize).toBe(50);
     expect(config.archivePageSize).toBe(50);
     expect(config.rssFeedLimit).toBe(50);
+    expect(config.rssPublishDelaySeconds).toBe(300);
   });
 
   it("DB settings override ENV and defaults", () => {
@@ -49,6 +52,16 @@ describe("resolveConfig", () => {
     expect(config.siteName).toBe("FromEnv");
   });
 
+  it("lets an explicit empty DB value override an environment fallback", () => {
+    const config = resolveConfig(
+      makeEnv({ SITE_DESCRIPTION: "From environment" }),
+      { SITE_DESCRIPTION: "" },
+    );
+
+    expect(config.siteDescription).toBe("");
+    expect(config.siteDescriptionExplicit).toBe(false);
+  });
+
   it("resolves mainRssFeed from DB, env, and defaults", () => {
     const defaultConfig = resolveConfig(makeEnv(), {});
     expect(defaultConfig.mainRssFeed).toBe("featured");
@@ -196,11 +209,15 @@ describe("resolveConfig", () => {
   it("resolves boolean fields correctly", () => {
     const config = resolveConfig(makeEnv(), {
       NOINDEX: "true",
+      PUBLIC_API_ENABLED: "false",
+      RSS_FEEDS_ENABLED: "false",
       SHOW_HEADER_AVATAR: "true",
       SHOW_JANT_BRANDING_ON_HOME: "true",
     });
 
     expect(config.noindex).toBe(true);
+    expect(config.publicApiEnabled).toBe(false);
+    expect(config.rssFeedsEnabled).toBe(false);
     expect(config.showHeaderAvatar).toBe(true);
     expect(config.showJantBrandingOnHome).toBe(true);
   });
@@ -232,6 +249,7 @@ describe("resolveConfig", () => {
         SEARCH_PAGE_SIZE: 7,
         ARCHIVE_PAGE_SIZE: "9",
         RSS_FEED_LIMIT: 25,
+        RSS_PUBLISH_DELAY_SECONDS: "600",
       }),
       {},
     );
@@ -239,6 +257,13 @@ describe("resolveConfig", () => {
     expect(config1.searchPageSize).toBe(7);
     expect(config1.archivePageSize).toBe(9);
     expect(config1.rssFeedLimit).toBe(25);
+    expect(config1.rssPublishDelaySeconds).toBe(600);
+
+    const configWithNoDelay = resolveConfig(
+      makeEnv({ RSS_PUBLISH_DELAY_SECONDS: 0 }),
+      {},
+    );
+    expect(configWithNoDelay.rssPublishDelaySeconds).toBe(0);
 
     const config2 = resolveConfig(
       makeEnv({
@@ -246,6 +271,7 @@ describe("resolveConfig", () => {
         SEARCH_PAGE_SIZE: 0,
         ARCHIVE_PAGE_SIZE: false,
         RSS_FEED_LIMIT: "invalid",
+        RSS_PUBLISH_DELAY_SECONDS: "-1",
       }),
       {},
     );
@@ -253,6 +279,92 @@ describe("resolveConfig", () => {
     expect(config2.searchPageSize).toBe(50);
     expect(config2.archivePageSize).toBe(50);
     expect(config2.rssFeedLimit).toBe(50);
+    expect(config2.rssPublishDelaySeconds).toBe(300);
+
+    const configWithBlankDelay = resolveConfig(
+      makeEnv({ RSS_PUBLISH_DELAY_SECONDS: "   " }),
+      {},
+    );
+    expect(configWithBlankDelay.rssPublishDelaySeconds).toBe(300);
+  });
+
+  it("resolves runtime numeric settings from DB before environment values", () => {
+    const config = resolveConfig(
+      makeEnv({
+        PAGE_SIZE: "20",
+        SEARCH_PAGE_SIZE: "25",
+        ARCHIVE_PAGE_SIZE: "30",
+        SUMMARY_MAX_PARAGRAPHS: "6",
+        SUMMARY_MAX_CHARS: "600",
+        RSS_FEED_LIMIT: "60",
+        RSS_PUBLISH_DELAY_SECONDS: "600",
+      }),
+      {
+        PAGE_SIZE: "80",
+        SUMMARY_MAX_PARAGRAPHS: "12",
+        SUMMARY_MAX_CHARS: "1200",
+        RSS_FEED_LIMIT: "120",
+        RSS_PUBLISH_DELAY_SECONDS: "0",
+      },
+    );
+
+    expect(config.pageSize).toBe(80);
+    expect(config.searchPageSize).toBe(25);
+    expect(config.archivePageSize).toBe(30);
+    expect(config.summaryMaxParagraphs).toBe(12);
+    expect(config.summaryMaxChars).toBe(1200);
+    expect(config.rssFeedLimit).toBe(120);
+    expect(config.rssPublishDelaySeconds).toBe(0);
+  });
+
+  it("inherits runtime page size and rejects out-of-range numeric values", () => {
+    const config = resolveConfig(
+      makeEnv({
+        PAGE_SIZE: "101",
+        SEARCH_PAGE_SIZE: "0",
+        ARCHIVE_PAGE_SIZE: "1.5",
+        SUMMARY_MAX_PARAGRAPHS: "51",
+        SUMMARY_MAX_CHARS: "1501",
+        RSS_FEED_LIMIT: "201",
+        RSS_PUBLISH_DELAY_SECONDS: "7201",
+      }),
+      { PAGE_SIZE: "75" },
+    );
+
+    expect(config.pageSize).toBe(75);
+    expect(config.searchPageSize).toBe(75);
+    expect(config.archivePageSize).toBe(75);
+    expect(config.summaryMaxParagraphs).toBe(5);
+    expect(config.summaryMaxChars).toBe(500);
+    expect(config.rssFeedLimit).toBe(50);
+    expect(config.rssPublishDelaySeconds).toBe(300);
+  });
+
+  it("resolves summary limits without the full app config", () => {
+    expect(
+      resolveSummaryConfig(
+        makeEnv({
+          SUMMARY_MAX_PARAGRAPHS: "3",
+          SUMMARY_MAX_CHARS: 240,
+        }),
+      ),
+    ).toEqual({ maxParagraphs: 3, maxChars: 240 });
+
+    expect(
+      resolveSummaryConfig(
+        makeEnv({
+          SUMMARY_MAX_PARAGRAPHS: 0,
+          SUMMARY_MAX_CHARS: "invalid",
+        }),
+      ),
+    ).toEqual({ maxParagraphs: 5, maxChars: 500 });
+
+    expect(
+      resolveSummaryConfig(makeEnv({ SUMMARY_MAX_CHARS: "240" }), {
+        SUMMARY_MAX_PARAGRAPHS: "8",
+        SUMMARY_MAX_CHARS: "900",
+      }),
+    ).toEqual({ maxParagraphs: 8, maxChars: 900 });
   });
 
   it("resolves fallbacks without DB values", () => {

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

@@ -801,6 +801,88 @@ describe("extractSummaryHtml", () => {
     expect(result!.html).toContain(">Link text</a>");
   });
 
+  it("includes referenced footnote definitions with the requested namespace", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [
+            { type: "text", text: "Visible" },
+            { type: "footnoteReference", attrs: { label: "note" } },
+          ],
+        },
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "Hidden tail" }],
+        },
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "note" },
+          content: [
+            {
+              type: "paragraph",
+              content: [{ type: "text", text: "Definition" }],
+            },
+          ],
+        },
+      ],
+    });
+
+    const result = extractSummaryHtml(doc, 1, 500, 0, {
+      namespace: "pst_summary",
+    });
+
+    expect(result?.hasMore).toBe(true);
+    expect(result?.html).toContain('id="fn-0pba1ne36oeor-1"');
+    expect(result?.html).toContain('role="doc-endnotes"');
+    expect(result?.html.match(/<ol class="footnote-list">/g)).toHaveLength(1);
+    expect(result?.html).not.toMatch(
+      /footnote-document|footnote-main|data-footnote-|--footnote-/,
+    );
+    expect(result?.html).not.toContain("Hidden tail");
+    expect(result!.html.indexOf("Definition")).toBeGreaterThan(
+      result!.html.indexOf("Visible"),
+    );
+  });
+
+  it("omits a footnote when its first reference is beyond the summary boundary", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "Visible summary" }],
+        },
+        {
+          type: "paragraph",
+          content: [
+            { type: "text", text: "Hidden reference" },
+            { type: "footnoteReference", attrs: { label: "note" } },
+          ],
+        },
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "note" },
+          content: [
+            {
+              type: "paragraph",
+              content: [{ type: "text", text: "Hidden definition" }],
+            },
+          ],
+        },
+      ],
+    });
+
+    const result = extractSummaryHtml(doc, 1, 500);
+
+    expect(result?.hasMore).toBe(true);
+    expect(result?.html).toContain("Visible summary");
+    expect(result?.html).not.toContain("Hidden reference");
+    expect(result?.html).not.toContain("Hidden definition");
+    expect(result?.html).not.toContain('role="doc-endnotes"');
+  });
+
   function paragraphsDoc(...texts: string[]): string {
     return JSON.stringify({
       type: "doc",

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);
+  });
+});