@jant/core 0.6.14 → 0.6.16

package/src/routes/dash/settings.tsx

@@ -18,7 +18,7 @@ import { renderPublicPage } from "../../lib/render.js";
 import { getNavigationData } from "../../lib/navigation.js";
 import { buildPageTitle } from "../../lib/page-title.js";
 import { AdminBreadcrumb } from "../../ui/shared/AdminBreadcrumb.js";
-import { TIMEZONES } from "../../lib/timezones.js";
+import { getTimeZoneOptions } from "../../lib/timezones.js";
 import { ValidationError } from "../../lib/errors.js";
 import { SETTINGS_KEYS } from "../../lib/constants.js";
 import { getAvailableThemes } from "../../lib/theme.js";
@@ -39,6 +39,7 @@ import { FontThemeContent } from "../../ui/dash/appearance/FontThemeContent.js";
 import { AdvancedContent } from "../../ui/dash/appearance/AdvancedContent.js";
 import { CodeInjectionContent } from "../../ui/dash/appearance/CodeInjectionContent.js";
 import { ApiTokensContent } from "../../ui/dash/settings/ApiTokensContent.js";
+import { ConfigEditorContent } from "../../ui/dash/settings/ConfigEditorContent.js";
 import { DeleteAccountContent } from "../../ui/dash/settings/DeleteAccountContent.js";
 import {
   GitHubSyncContent,
@@ -78,6 +79,7 @@ import {
   triggerGitHubSyncInline,
 } from "../../lib/github-sync-trigger.js";
 import { buildSyncSiteConfig } from "../../lib/github-sync-site-config.js";
+import { buildConfigEditorFields } from "../../lib/api-settings.js";
 import {
   readGitHubSyncStatus,
   renderStatusCardHtml,
@@ -142,6 +144,7 @@ function breadcrumbLabel(
     | "fontTheme"
     | "customCss"
     | "codeInjection"
+    | "config"
     | "account"
     | "sessions"
     | "password"
@@ -187,6 +190,13 @@ function breadcrumbLabel(
           comment: "@context: Breadcrumb label",
         }),
       );
+    case "config":
+      return i18n._(
+        msg({
+          message: "Config Editor",
+          comment: "@context: Breadcrumb label",
+        }),
+      );
     case "account":
       return i18n._(
         msg({
@@ -366,7 +376,7 @@ settingsRoutes.get("/general", async (c) => {
           showJantBrandingOnHome={appConfig.showJantBrandingOnHome}
           noindex={appConfig.noindex}
           demoMode={appConfig.demoMode}
-          timezones={TIMEZONES}
+          timezones={getTimeZoneOptions(appConfig.timeZone)}
           aboutPage={aboutPage}
           aboutEditUrl={aboutEditPath(c)}
           aboutCreateUrl={publicPath(c, "/settings/general/about-page")}
@@ -808,6 +818,7 @@ settingsRoutes.get("/navigation", async (c) => {
           directoryData={directoryData}
           suggestedLinks={suggestedLinks}
           mainRssFeed={c.var.appConfig.mainRssFeed}
+          rssFeedsEnabled={c.var.appConfig.rssFeedsEnabled}
           siteName={navData.siteName}
           sitePathPrefix={c.var.appConfig.sitePathPrefix}
         />
@@ -1051,6 +1062,38 @@ settingsRoutes.post("/code-injection", async (c) => {
   );
 });
 
+// ===========================================================================
+// Config Editor — explicitly approved runtime settings only.
+// ===========================================================================
+
+settingsRoutes.get("/config", async (c) => {
+  const navData = await getNavigationData(c);
+  const fields = buildConfigEditorFields(
+    c.var.allSettings,
+    c.env,
+    c.var.appConfig.demoMode,
+  );
+
+  return renderPublicPage(c, {
+    title: buildPageTitle("Config Editor", navData.siteName),
+    navData,
+    content: (
+      <>
+        <AdminBreadcrumb
+          parent={breadcrumbLabel(c, "settings")}
+          parentHref={publicPath(c, "/settings")}
+          current={breadcrumbLabel(c, "config")}
+        />
+        <ConfigEditorContent
+          fields={fields}
+          endpoint={publicPath(c, "/api/settings")}
+          sitePathPrefix={c.var.appConfig.sitePathPrefix}
+        />
+      </>
+    ),
+  });
+});
+
 // ===========================================================================
 // Account sub-menu
 // ===========================================================================

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

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { eq } from "drizzle-orm";
 import { Hono } from "hono";
 import type { Bindings } from "../../../types.js";
@@ -43,6 +43,7 @@ function createFeedTestApp(envOverrides: Partial<Bindings> = {}) {
     const env = {
       SITE_ORIGIN: `http://localhost:${DEFAULT_APP_PORT}`,
       SITE_PATH_PREFIX: "",
+      RSS_PUBLISH_DELAY_SECONDS: 0,
       ...envOverrides,
     } as Bindings;
     c.env = env;
@@ -67,6 +68,10 @@ function createFeedTestApp(envOverrides: Partial<Bindings> = {}) {
   return { app, services, db: db as unknown as Database };
 }
 
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
 describe("Atom Feed Routes", () => {
   describe("/feed — site main feed", () => {
     it("defaults to featured posts", async () => {
@@ -170,9 +175,10 @@ describe("Atom Feed Routes", () => {
       expect(res.headers.get("Content-Type")).toBe(
         "application/atom+xml; charset=utf-8",
       );
+      expect(res.headers.get("Cache-Control")).toBe("public, max-age=60");
     });
 
-    it("orders featured items by featuredAt and preserves original publishedAt", async () => {
+    it("orders Featured Threads by selected Post publication time", async () => {
       const { app, services, db } = createFeedTestApp();
 
       const olderPublished = await services.posts.create({
@@ -203,11 +209,9 @@ describe("Atom Feed Routes", () => {
       expect(res.status).toBe(200);
 
       const xml = await res.text();
-      // Older published should appear first because it has a later featuredAt
-      expect(xml.indexOf("Older published")).toBeLessThan(
-        xml.indexOf("Newer published"),
+      expect(xml.indexOf("Newer published")).toBeLessThan(
+        xml.indexOf("Older published"),
       );
-      // <published> should reflect original publishedAt, not featuredAt
       expect(xml).toContain("<published>1970-01-01T00:16:40.000Z</published>");
       expect(xml).toContain("<published>1970-01-01T00:33:20.000Z</published>");
     });
@@ -352,6 +356,45 @@ describe("Atom Feed Routes", () => {
       expect(xml).toContain("Featured Post");
       expect(xml).not.toContain("Regular Post");
     });
+
+    it("deduplicates by Thread and orders from a Featured Child publication", async () => {
+      const { app, services } = createFeedTestApp();
+
+      const olderRoot = await services.posts.create({
+        format: "note",
+        title: "Older Thread Root",
+        bodyMarkdown: "Older root body",
+        status: "published",
+        publishedAt: 1000,
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Featured Child",
+        bodyMarkdown: "Selected child body",
+        status: "published",
+        replyToId: olderRoot.id,
+        featured: true,
+        publishedAt: 3000,
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Newer Root",
+        bodyMarkdown: "Newer root body",
+        status: "published",
+        featured: true,
+        publishedAt: 2000,
+      });
+
+      const res = await app.request("/featured/feed");
+      expect(res.status).toBe(200);
+
+      const xml = await res.text();
+      expect(xml.match(/<entry>/g)).toHaveLength(2);
+      expect(xml).toContain("Selected child body");
+      expect(xml.indexOf("Older Thread Root")).toBeLessThan(
+        xml.indexOf("Newer Root"),
+      );
+    });
   });
 
   describe("legacy feed path redirects", () => {
@@ -432,6 +475,33 @@ describe("Atom Feed Routes", () => {
     });
   });
 
+  it("emits canonical v3 footnotes from a stale stored projection", async () => {
+    const { app, services, db } = createFeedTestApp();
+    const post = await services.posts.create({
+      format: "note",
+      title: "Footnote feed",
+      bodyMarkdown: "Feed body[^1]\n\n[^1]: Feed definition",
+      status: "published",
+    });
+    await db
+      .update(postTable)
+      .set({
+        bodyHtml: '<span class="sidenote">legacy</span>',
+        bodyHtmlVersion: 1,
+      })
+      .where(eq(postTable.id, post.id));
+
+    const response = await app.request("/latest/feed");
+    const xml = await response.text();
+
+    expect(response.status).toBe(200);
+    expect(xml).toContain('role="doc-noteref"');
+    expect(xml).toContain('role="doc-endnotes"');
+    expect(xml).toMatch(/id="fn-[a-z0-9]{13}-1"/);
+    expect(xml).not.toContain(`fn-${post.id}`);
+    expect(xml).not.toContain("legacy");
+  });
+
   describe("RSS_FEED_LIMIT env var", () => {
     it("defaults to 50 when RSS_FEED_LIMIT is not set", async () => {
       const { app, services } = createFeedTestApp();
@@ -527,6 +597,85 @@ describe("Atom Feed Routes", () => {
     });
   });
 
+  describe("RSS_PUBLISH_DELAY_SECONDS env var", () => {
+    it("includes the exact 300-second boundary and excludes newer Posts", async () => {
+      const currentTime = 2_000_000;
+      vi.spyOn(Date, "now").mockReturnValue(currentTime * 1000);
+      const { app, services } = createFeedTestApp({
+        RSS_PUBLISH_DELAY_SECONDS: 300,
+      });
+
+      await services.posts.create({
+        format: "note",
+        title: "Boundary Post",
+        bodyMarkdown: "Eligible at exactly five minutes",
+        status: "published",
+        publishedAt: currentTime - 300,
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Recent Post",
+        bodyMarkdown: "Still inside the edit window",
+        status: "published",
+        publishedAt: currentTime - 299,
+      });
+
+      const xml = await (await app.request("/latest/feed")).text();
+
+      expect(xml).toContain("Boundary Post");
+      expect(xml).not.toContain("Recent Post");
+    });
+
+    it("applies the delay to Featured Posts", async () => {
+      const currentTime = 2_000_000;
+      vi.spyOn(Date, "now").mockReturnValue(currentTime * 1000);
+      const { app, services } = createFeedTestApp({
+        RSS_PUBLISH_DELAY_SECONDS: 300,
+      });
+
+      await services.posts.create({
+        format: "note",
+        title: "Eligible Featured Post",
+        bodyMarkdown: "Old enough",
+        status: "published",
+        featured: true,
+        publishedAt: currentTime - 300,
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Recent Featured Post",
+        bodyMarkdown: "Too new",
+        status: "published",
+        featured: true,
+        publishedAt: currentTime,
+      });
+
+      const xml = await (await app.request("/featured/feed")).text();
+
+      expect(xml).toContain("Eligible Featured Post");
+      expect(xml).not.toContain("Recent Featured Post");
+    });
+
+    it("lets zero disable the delay", async () => {
+      const currentTime = 2_000_000;
+      vi.spyOn(Date, "now").mockReturnValue(currentTime * 1000);
+      const { app, services } = createFeedTestApp({
+        RSS_PUBLISH_DELAY_SECONDS: 0,
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Immediate Post",
+        bodyMarkdown: "No edit window",
+        status: "published",
+        publishedAt: currentTime,
+      });
+
+      const xml = await (await app.request("/latest/feed")).text();
+
+      expect(xml).toContain("Immediate Post");
+    });
+  });
+
   describe("thread content in feed", () => {
     it("includes thread replies inline with hr separators", async () => {
       const { app, services } = createFeedTestApp();
@@ -552,5 +701,60 @@ describe("Atom Feed Routes", () => {
       expect(xml).toContain("Reply content");
       expect(xml).toContain("<hr/>");
     });
+
+    it("delays new replies inside an already eligible Thread", async () => {
+      const currentTime = 2_000_000;
+      const dateNow = vi.spyOn(Date, "now").mockReturnValue(currentTime * 1000);
+      const { app, services } = createFeedTestApp({
+        RSS_PUBLISH_DELAY_SECONDS: 300,
+      });
+      const root = await services.posts.create({
+        format: "note",
+        title: "Eligible Thread Root",
+        bodyMarkdown: "Root content",
+        status: "published",
+        publishedAt: currentTime - 600,
+      });
+      await services.posts.create({
+        format: "note",
+        bodyMarkdown: "Recent reply content",
+        status: "published",
+        replyToId: root.id,
+        publishedAt: currentTime,
+      });
+
+      const beforeDelay = await (await app.request("/latest/feed")).text();
+      expect(beforeDelay).toContain("Root content");
+      expect(beforeDelay).not.toContain("Recent reply content");
+
+      dateNow.mockReturnValue((currentTime + 300) * 1000);
+      const afterDelay = await (await app.request("/latest/feed")).text();
+      expect(afterDelay).toContain("Recent reply content");
+    });
+
+    it("reflects eligible content edits in the Atom entry updated timestamp", async () => {
+      const currentTime = 2_000_000;
+      vi.spyOn(Date, "now").mockReturnValue(currentTime * 1000);
+      const { app, services } = createFeedTestApp({
+        RSS_PUBLISH_DELAY_SECONDS: 300,
+      });
+      const root = await services.posts.create({
+        format: "note",
+        title: "Edited Post",
+        bodyMarkdown: "Original copy",
+        status: "published",
+        publishedAt: currentTime - 300,
+      });
+      await services.posts.update(root.id, {
+        bodyMarkdown: "Corrected copy",
+      });
+
+      const xml = await (await app.request("/latest/feed")).text();
+      const entry = xml.match(/<entry>[\s\S]*?<\/entry>/)?.[0];
+
+      expect(entry).toContain("Corrected copy");
+      expect(entry).not.toContain("Original copy");
+      expect(entry).toContain("<updated>1970-01-24T03:33:20.000Z</updated>");
+    });
   });
 });

package/src/routes/feed/__tests__/sitemap.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import { Hono } from "hono";
 import type { Bindings } from "../../../types.js";
 import type { AppVariables } from "../../../types/app-context.js";
@@ -154,6 +154,73 @@ describe("Sitemap Routes", () => {
       expect(indices).toEqual([...indices].sort((a, b) => a - b));
     });
 
+    // A Thread root's page renders its replies, so anything that changes a
+    // reply changes the page. Unlike ordering, edits count for <lastmod> —
+    // the page really did change.
+    it("moves <lastmod> when a reply is added", async () => {
+      const { app, services } = createSitemapTestApp();
+      const readLastmod = async () => {
+        const xml = await (await app.request("/sitemap-posts-1.xml")).text();
+        return /<lastmod>([^<]+)<\/lastmod>/.exec(xml)?.[1];
+      };
+
+      vi.useFakeTimers();
+      try {
+        // lastmod is a date, so the two writes need to land on different days.
+        vi.setSystemTime(new Date("2026-03-01T00:00:00Z"));
+        const root = await services.posts.create({
+          format: "note",
+          bodyMarkdown: "root",
+          title: "Threaded",
+          status: "published",
+        });
+        expect(await readLastmod()).toBe("2026-03-01");
+
+        vi.setSystemTime(new Date("2026-03-05T00:00:00Z"));
+        await services.posts.create({
+          format: "note",
+          bodyMarkdown: "reply",
+          replyToId: root.id,
+          status: "published",
+        });
+        expect(await readLastmod()).toBe("2026-03-05");
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it("ignores a draft reply in <lastmod>", async () => {
+      const { app, services } = createSitemapTestApp();
+      const readLastmod = async () => {
+        const xml = await (await app.request("/sitemap-posts-1.xml")).text();
+        return /<lastmod>([^<]+)<\/lastmod>/.exec(xml)?.[1];
+      };
+
+      vi.useFakeTimers();
+      try {
+        vi.setSystemTime(new Date("2026-03-01T00:00:00Z"));
+        const root = await services.posts.create({
+          format: "note",
+          bodyMarkdown: "root",
+          title: "Threaded",
+          status: "published",
+        });
+
+        vi.setSystemTime(new Date("2026-03-05T00:00:00Z"));
+        await services.posts.create({
+          format: "note",
+          bodyMarkdown: "unpublished reply",
+          replyToId: root.id,
+          status: "draft",
+        });
+
+        // Not on the page, so it must not claim the page changed.
+        expect(await readLastmod()).toBe("2026-03-01");
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
     it("excludes private posts, replies, and drafts", async () => {
       const { app, services } = createSitemapTestApp();
       const root = await services.posts.create({

package/src/routes/feed/feed.ts

@@ -27,9 +27,13 @@ import type {
 } from "../../types.js";
 import type { AppVariables } from "../../types/app-context.js";
 import { defaultFeedRenderer } from "../../lib/feed.js";
+import {
+  getFeedEntryUpdatedAt,
+  getRssPublishedBefore,
+  RSS_FEED_CACHE_CONTROL,
+} from "../../lib/feed-policy.js";
 import { buildMediaMap } from "../../lib/media-helpers.js";
 import { getI18n } from "../../i18n/index.js";
-import { toISOString } from "../../lib/time.js";
 import { FORMATS } from "../../types/constants.js";
 
 import { createMediaContext, toPostViews } from "../../lib/view.js";
@@ -118,6 +122,7 @@ function collectReplyIds(threadMap: Map<string, Post[]>): string[] {
 async function buildLatestFeedData(
   c: Context<Env>,
   feedLimit: number,
+  publishedBefore: number,
   format?: Format,
 ): Promise<{ posts: Post[]; postViews: FeedPostView[] }> {
   const posts = await c.var.services.posts.list({
@@ -127,6 +132,7 @@ async function buildLatestFeedData(
     excludePrivate: true,
     format,
     ignorePinnedSort: true,
+    publishedBefore,
     limit: feedLimit,
   });
 
@@ -135,7 +141,7 @@ async function buildLatestFeedData(
 
   const mediaCtx = createMediaContext(c.var.appConfig);
   const [threadMap, mediaMap, aliasesMap] = await Promise.all([
-    c.var.services.posts.getPublishedThreads(rootIds),
+    c.var.services.posts.getPublishedThreads(rootIds, { publishedBefore }),
     loadMediaMap(c, postIds, mediaCtx),
     c.var.services.paths.getPostAliases(postIds),
   ]);
@@ -162,9 +168,10 @@ async function buildLatestFeedData(
     aliasMap,
   ).map((postView, index) => {
     const post = posts[index] as (typeof posts)[number];
+    const thread = threadMap.get(post.id);
     return {
       ...postView,
-      feedUpdatedAt: toISOString(post.lastActivityAt),
+      feedUpdatedAt: getFeedEntryUpdatedAt(post, thread),
       threadReplies: buildThreadReplies(
         post.id,
         threadMap,
@@ -187,10 +194,12 @@ async function buildLatestFeedData(
 async function buildFeaturedFeedData(
   c: Context<Env>,
   feedLimit: number,
+  publishedBefore: number,
 ): Promise<{ posts: Post[]; postViews: FeedPostView[] }> {
   const rootIds = await c.var.services.posts.listFeaturedThreadRootIds({
     status: "published",
     excludePrivate: true,
+    publishedBefore,
     limit: feedLimit,
   });
 
@@ -198,7 +207,9 @@ async function buildFeaturedFeedData(
     return { posts: [], postViews: [] };
   }
 
-  const threadMap = await c.var.services.posts.getPublishedThreads(rootIds);
+  const threadMap = await c.var.services.posts.getPublishedThreads(rootIds, {
+    publishedBefore,
+  });
 
   // Extract root posts in the same order as rootIds
   const posts: Post[] = [];
@@ -241,16 +252,11 @@ async function buildFeaturedFeedData(
     aliasMap,
   ).map((postView, index) => {
     const post = posts[index] as (typeof posts)[number];
-
-    // feedUpdatedAt = max(lastActivityAt, featuredAt)
-    const lastActivity = toISOString(post.lastActivityAt);
-    const featuredIso = post.featuredAt ? toISOString(post.featuredAt) : null;
-    const feedUpdatedAt =
-      featuredIso && featuredIso > lastActivity ? featuredIso : lastActivity;
+    const thread = threadMap.get(post.id);
 
     return {
       ...postView,
-      feedUpdatedAt,
+      feedUpdatedAt: getFeedEntryUpdatedAt(post, thread),
       threadReplies: buildThreadReplies(post.id, threadMap, mediaMap, mediaCtx),
     };
   });
@@ -280,12 +286,15 @@ export async function buildFeedData(
   const siteUrl = appConfig.siteUrl;
   const siteLanguage = appConfig.siteLanguage;
   const feedLimit = appConfig.rssFeedLimit;
+  const publishedBefore = getRssPublishedBefore(
+    appConfig.rssPublishDelaySeconds,
+  );
   const kind = opts.kind;
 
   const { postViews } =
     kind === "featured"
-      ? await buildFeaturedFeedData(c, feedLimit)
-      : await buildLatestFeedData(c, feedLimit, opts.format);
+      ? await buildFeaturedFeedData(c, feedLimit, publishedBefore)
+      : await buildLatestFeedData(c, feedLimit, publishedBefore, opts.format);
 
   return {
     siteName,
@@ -333,7 +342,7 @@ export function renderFeed(xml: string) {
   return new Response(xml, {
     headers: {
       "Content-Type": "application/atom+xml; charset=utf-8",
-      "Cache-Control": "public, max-age=180",
+      "Cache-Control": RSS_FEED_CACHE_CONTROL,
     },
   });
 }