@jant/core 0.6.14 → 0.6.15

package/dist/{github-sync-Ckk0sJxK.js → github-sync-Cq1pzzOI.js}

@@ -1,4 +1,4 @@
-import { c as parseMarkdownDocument, r as parseFrontMatter, t as createExportService } from "./export-DWn149b7.js";
+import { c as parseMarkdownDocument, r as parseFrontMatter, t as createExportService } from "./export-CsFx6F_M.js";
 import { r as getInstallationToken } from "./github-app-BbklkFmU.js";
 import { r as parseRepoSlug, t as createGitHubClient } from "./github-api-BgSiE71w.js";
 //#region src/lib/markdown-to-tiptap.ts

package/dist/{github-sync-C0zyF6XS.js → github-sync-ppWXN3jb.js}

@@ -1,4 +1,4 @@
 import "./url-BMYO-Zlt.js";
-import "./export-DWn149b7.js";
-import { i as classifyRepoForSync, o as createGitHubSyncService } from "./github-sync-Ckk0sJxK.js";
+import "./export-CsFx6F_M.js";
+import { i as classifyRepoForSync, o as createGitHubSyncService } from "./github-sync-Cq1pzzOI.js";
 export { classifyRepoForSync, createGitHubSyncService };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { y as url_exports } from "./url-BMYO-Zlt.js";
-import { A as MAX_MEDIA_ATTACHMENTS, C as toMediaView, D as toPostViews, E as toPostView, F as STATUSES, I as TEXT_ATTACHMENT_CONTENT_FORMATS, M as MEDIA_KINDS, N as NAV_ITEM_TYPES, O as toSearchResultView, P as SORT_ORDERS, S as toArchiveGroupsWithMedia, T as toNavItemViews, b as createMediaContext, j as MAX_PINNED_POSTS, k as FORMATS, m as defaultFeedRenderer, t as createApp, w as toNavItemView, x as toArchiveGroups } from "./app-2i7-WQHg.js";
-import { S as time_exports, a as markdown_exports } from "./export-DWn149b7.js";
+import { C as toPostView, S as toNavItemViews, T as toSearchResultView, _ as createMediaContext, b as toMediaView, d as defaultFeedRenderer, t as createApp, v as toArchiveGroups, w as toPostViews, x as toNavItemView, y as toArchiveGroupsWithMedia } from "./app-C-oi_t8W.js";
+import { B as STATUSES, L as MEDIA_KINDS, N as MAX_MEDIA_ATTACHMENTS, P as MAX_PINNED_POSTS, R as NAV_ITEM_TYPES, W as TEXT_ATTACHMENT_CONTENT_FORMATS, a as markdown_exports, j as FORMATS, w as time_exports, z as SORT_ORDERS } from "./export-CsFx6F_M.js";
 import "./env-OHRKGcMj.js";
-import "./github-sync-Ckk0sJxK.js";
+import "./github-sync-Cq1pzzOI.js";
 export { FORMATS, MAX_MEDIA_ATTACHMENTS, MAX_PINNED_POSTS, MEDIA_KINDS, NAV_ITEM_TYPES, SORT_ORDERS, STATUSES, TEXT_ATTACHMENT_CONTENT_FORMATS, createApp, createMediaContext, defaultFeedRenderer, markdown_exports as markdown, time_exports as time, toArchiveGroups, toArchiveGroupsWithMedia, toMediaView, toNavItemView, toNavItemViews, toPostView, toPostViews, toSearchResultView, url_exports as url };

package/dist/node.js

@@ -1,8 +1,8 @@
 import "./url-BMYO-Zlt.js";
-import { B as isAssetPath, L as buildThemeStyle, R as BUILTIN_COLOR_THEMES, _ as sqliteSchemaBundle, a as resolveDatabaseDialect, c as getWebhookUrl, d as BUILTIN_FONT_THEMES, f as getCjkSerifCssVariables, g as pgSchemaBundle, h as createStorageDriver, i as createSiteService, l as setMyCommands, n as createNodeCliRuntime, o as getHostBasedStartupConfigurationIssues, p as getFontThemeCssVariables, r as createNodeRequestRuntime, s as resolveConfig, t as createApp, u as setWebhook, v as createNodeDatabase, y as schema_exports, z as getPublicAssetBasePath } from "./app-2i7-WQHg.js";
-import { t as createExportService } from "./export-DWn149b7.js";
+import { A as buildThemeStyle, D as getCjkFontCssVariables, E as BUILTIN_FONT_THEMES, M as getPublicAssetBasePath, N as isAssetPath, O as getFontThemeCssVariables, a as getHostBasedStartupConfigurationIssues, c as getWebhookUrl, f as createStorageDriver, g as schema_exports, h as createNodeDatabase, i as createSiteService, j as BUILTIN_COLOR_THEMES, k as resolveCjkFontProfile, l as setMyCommands, m as sqliteSchemaBundle, n as createNodeCliRuntime, o as resolveDatabaseDialect, p as pgSchemaBundle, r as createNodeRequestRuntime, s as resolveConfig, t as createApp, u as setWebhook } from "./app-C-oi_t8W.js";
+import { t as createExportService } from "./export-CsFx6F_M.js";
 import { C as shouldTrustProxy, S as getTelegramWebhookSecret, b as getSiteResolutionMode, d as getHostedControlPlaneBaseUrl, i as getConfiguredSingleSitePathPrefix, l as getEnvString, r as getConfiguredSingleSiteOrigin, x as getTelegramBotPool, y as getPort } from "./env-OHRKGcMj.js";
-import "./github-sync-Ckk0sJxK.js";
+import "./github-sync-Cq1pzzOI.js";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { serve } from "@hono/node-server";
 import Database from "better-sqlite3";
@@ -529,7 +529,7 @@ async function createNodeRequestHandler(options) {
 async function start(env = process.env, app) {
 	const handler = await createNodeRequestHandler({
 		env,
-		app: async () => app ?? (await import("./app-DZDlmh7C.js")).createApp()
+		app: async () => app ?? (await import("./app-BxCOR3Uc.js")).createApp()
 	});
 	const hostname = resolveHost(env);
 	const port = resolvePort(env);
@@ -574,4 +574,4 @@ async function start(env = process.env, app) {
 	});
 }
 //#endregion
-export { BUILTIN_COLOR_THEMES, BUILTIN_FONT_THEMES, buildThemeStyle, createApp, createExportService, createNodeBindings, createNodeCliRuntime, createNodeRequestHandler, createNodeRequestRuntime, createStorageDriver, getCjkSerifCssVariables, getFontThemeCssVariables, migrate, resolveConfig, start };
+export { BUILTIN_COLOR_THEMES, BUILTIN_FONT_THEMES, buildThemeStyle, createApp, createExportService, createNodeBindings, createNodeCliRuntime, createNodeRequestHandler, createNodeRequestRuntime, createStorageDriver, getCjkFontCssVariables, getFontThemeCssVariables, migrate, resolveCjkFontProfile, resolveConfig, start };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jant/core",
-  "version": "0.6.14",
+  "version": "0.6.15",
   "description": "A modern, open-source microblogging platform built on Cloudflare Workers",
   "type": "module",
   "exports": {
@@ -37,15 +37,16 @@
     "@lingui/core": "^5.9.3",
     "@lingui/react": "^5.9.3",
     "@tailwindcss/typography": "^0.5.19",
-    "@tiptap/core": "^3.22.1",
-    "@tiptap/extension-code-block": "^3.22.1",
-    "@tiptap/extension-image": "^3.22.1",
-    "@tiptap/extension-placeholder": "^3.22.1",
-    "@tiptap/extension-table": "^3.22.1",
-    "@tiptap/markdown": "^3.22.1",
-    "@tiptap/pm": "^3.22.1",
-    "@tiptap/starter-kit": "^3.22.1",
-    "@tiptap/suggestion": "^3.22.1",
+    "@tiptap/core": "^3.27.3",
+    "@tiptap/extension-code-block": "^3.27.3",
+    "@tiptap/extension-image": "^3.27.3",
+    "@tiptap/extension-link": "^3.27.3",
+    "@tiptap/extension-placeholder": "^3.27.3",
+    "@tiptap/extension-table": "^3.27.3",
+    "@tiptap/markdown": "^3.27.3",
+    "@tiptap/pm": "^3.27.3",
+    "@tiptap/starter-kit": "^3.27.3",
+    "@tiptap/suggestion": "^3.27.3",
     "basecoat-css": "^0.3.11",
     "better-auth": "^1.5.5",
     "better-sqlite3": "^12.8.0",

package/src/__tests__/bin/posts-rebuild-html.test.ts

@@ -0,0 +1,137 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { run } from "../../../bin/commands/posts/rebuild-html.js";
+import { POST_BODY_HTML_VERSION } from "../../lib/post-body-html.js";
+
+const originalEnv = {
+  INTERNAL_ADMIN_TOKEN: process.env.INTERNAL_ADMIN_TOKEN,
+  SITE_ORIGIN: process.env.SITE_ORIGIN,
+  SITE_PATH_PREFIX: process.env.SITE_PATH_PREFIX,
+};
+
+afterEach(() => {
+  for (const [key, value] of Object.entries(originalEnv)) {
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+function batchResponse(overrides: Record<string, unknown> = {}) {
+  return new Response(
+    JSON.stringify({
+      processed: 1,
+      wouldRebuild: 1,
+      rebuilt: 1,
+      wouldUpgradeFootnotes: 0,
+      upgradedFootnotes: 0,
+      skipped: 0,
+      conflicted: 0,
+      failed: 0,
+      failures: [],
+      nextCursor: null,
+      done: true,
+      targetVersion: POST_BODY_HTML_VERSION,
+      ...overrides,
+    }),
+    { status: 200, headers: { "Content-Type": "application/json" } },
+  );
+}
+
+describe("jant posts rebuild-html", () => {
+  it("paginates the current site and preserves dry-run mode", async () => {
+    process.env.INTERNAL_ADMIN_TOKEN = "internal-secret";
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(
+        batchResponse({
+          processed: 2,
+          wouldRebuild: 2,
+          rebuilt: 0,
+          nextCursor: "pst_cursor",
+          done: false,
+        }),
+      )
+      .mockResolvedValueOnce(
+        batchResponse({ processed: 1, rebuilt: 0, wouldRebuild: 1 }),
+      );
+    vi.stubGlobal("fetch", fetchMock);
+    vi.spyOn(console, "log").mockImplementation(() => {});
+
+    await run([
+      "--url",
+      "https://example.com/blog",
+      "--limit",
+      "2",
+      "--dry-run",
+    ]);
+
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      1,
+      "https://example.com/blog/api/internal/posts/body-html/rebuild",
+      expect.objectContaining({
+        method: "POST",
+        headers: {
+          Authorization: "Bearer internal-secret",
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ limit: 2, dryRun: true }),
+      }),
+    );
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      2,
+      "https://example.com/blog/api/internal/posts/body-html/rebuild",
+      expect.objectContaining({
+        body: JSON.stringify({
+          limit: 2,
+          cursor: "pst_cursor",
+          dryRun: true,
+        }),
+      }),
+    );
+  });
+
+  it("targets one explicit managed site without fleet-wide discovery", async () => {
+    const fetchMock = vi.fn().mockResolvedValue(batchResponse());
+    vi.stubGlobal("fetch", fetchMock);
+    vi.spyOn(console, "log").mockImplementation(() => {});
+
+    await run([
+      "--url",
+      "https://core.example.com",
+      "--site",
+      "sit_managed",
+      "--token",
+      "secret",
+      "--once",
+    ]);
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://core.example.com/api/internal/sites/sit_managed/posts/body-html/rebuild",
+      expect.objectContaining({
+        body: JSON.stringify({ limit: 50 }),
+      }),
+    );
+  });
+
+  it("aborts when pagination does not advance", async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(
+        batchResponse({ nextCursor: "pst_same", done: false }),
+      )
+      .mockResolvedValueOnce(
+        batchResponse({ nextCursor: "pst_same", done: false }),
+      );
+    vi.stubGlobal("fetch", fetchMock);
+    vi.spyOn(console, "log").mockImplementation(() => {});
+
+    await expect(
+      run(["--url", "https://example.com", "--token", "secret"]),
+    ).rejects.toThrow("without advancing the cursor");
+  });
+});

package/src/__tests__/dev-navigation-defaults.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { DEFAULT_NAVIGATION_SEED_ITEMS } from "../../dev/scripts/dev-auth-db.mjs";
+import {
+  DEFAULT_NAVIGATION_PROFILE,
+  SYSTEM_NAV_KEYS,
+} from "../types/constants.js";
+
+describe("dev navigation bootstrap", () => {
+  it("derives the translated-label seed rows from the shared profile", () => {
+    expect(DEFAULT_NAVIGATION_SEED_ITEMS).toEqual(
+      DEFAULT_NAVIGATION_PROFILE.systemKeys.map((systemKey) => ({
+        systemKey,
+        label: "",
+        url: SYSTEM_NAV_KEYS[systemKey].url,
+        placement: SYSTEM_NAV_KEYS[systemKey].defaultPlacement,
+      })),
+    );
+    expect(
+      DEFAULT_NAVIGATION_SEED_ITEMS.map((item) => item.systemKey),
+    ).not.toContain("latest");
+  });
+});

package/src/__tests__/export-hugo-build.test.ts

@@ -6,7 +6,14 @@
  */
 
 import { spawn, spawnSync } from "node:child_process";
-import { mkdir, mkdtemp, rm, stat, writeFile } from "node:fs/promises";
+import {
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
@@ -71,6 +78,7 @@ function buildFixtureServices(): ServicesArg {
     threadId: "pst_root",
     createdAt: 1773020000,
     publishedAt: 1773020000,
+    featuredAt: 1773030000,
   });
   const collection = makeCollection({ id: "col-1", slug: "ideas" });
   const media = makeMedia({ id: "med_hero", filename: "hero.webp" });
@@ -95,15 +103,29 @@ function buildFixtureServices(): ServicesArg {
             type: "collection" as const,
             collection: {
               ...collection,
-              postCount: 1,
+              threadCount: 1,
               recentActivityAt: collection.updatedAt,
             },
           },
         ],
         directoryItems: [],
       }),
-      getCollectionsByPostIds: async () => new Map(),
-      getCollectionEntriesByPostIds: async () => new Map(),
+      getCollectionsByPostIds: async () =>
+        new Map([["pst_root", [collection]]]),
+      getCollectionEntriesByThreadIds: async () =>
+        new Map([
+          [
+            "pst_root",
+            [
+              {
+                collectionId: "col-1",
+                createdAt: 1773020000,
+                position: 0,
+                pinnedAt: null,
+              },
+            ],
+          ],
+        ]),
     },
     media: {
       getByPostIds: async () => new Map([["pst_root", [media]]]),
@@ -166,13 +188,50 @@ describe("Hugo smoke build", () => {
     for (const rel of [
       "public/index.html",
       "public/featured/index.html",
+      "public/featured/index.xml",
       "public/archive/index.html",
       "public/collections/index.html",
+      "public/ideas/index.html",
+      "public/ideas/index.xml",
       "public/hello-world/index.html",
       // Alias page for the reply slug (root aliases include /hello-reply/).
       "public/hello-reply/index.html",
     ]) {
       expect(await fileExists(join(tempDir, rel)), `missing ${rel}`).toBe(true);
     }
+
+    const collectionHtml = await readFile(
+      join(tempDir, "public/ideas/index.html"),
+      "utf-8",
+    );
+    expect(collectionHtml).toContain("Hello World");
+    expect(collectionHtml).toContain("Follow-up");
+    expect(collectionHtml).toMatch(
+      /class="thread thread-full thread-has-replies"/,
+    );
+
+    const collectionFeed = await readFile(
+      join(tempDir, "public/ideas/index.xml"),
+      "utf-8",
+    );
+    expect(collectionFeed).toContain("Hello World");
+    expect(collectionFeed).toContain("Follow-up");
+    expect(collectionFeed.match(/<entry>/g)).toHaveLength(1);
+
+    const featuredHtml = await readFile(
+      join(tempDir, "public/featured/index.html"),
+      "utf-8",
+    );
+    expect(featuredHtml).toContain("Hello World");
+    expect(featuredHtml).toContain("Follow-up");
+    expect(featuredHtml).toContain("thread-item-featured");
+
+    const featuredFeed = await readFile(
+      join(tempDir, "public/featured/index.xml"),
+      "utf-8",
+    );
+    expect(featuredFeed).toContain("Hello World");
+    expect(featuredFeed).toContain("Follow-up");
+    expect(featuredFeed.match(/<entry>/g)).toHaveLength(1);
   }, 60_000);
 });

package/src/__tests__/export-import-roundtrip.test.ts

@@ -31,7 +31,7 @@ function buildRoundtripServices(opts: {
   posts: Post[];
   collections: Collection[];
   mediaByPost: Map<string, Media[]>;
-  collectionEntriesByPost: Map<
+  collectionEntriesByThread: Map<
     string,
     {
       collectionId: string;
@@ -65,14 +65,15 @@ function buildRoundtripServices(opts: {
           type: "collection" as const,
           collection: {
             ...collection,
-            postCount: 0,
+            threadCount: 0,
             recentActivityAt: collection.updatedAt,
           },
         })),
         directoryItems: [],
       }),
       getCollectionsByPostIds: async () => new Map(),
-      getCollectionEntriesByPostIds: async () => opts.collectionEntriesByPost,
+      getCollectionEntriesByThreadIds: async () =>
+        opts.collectionEntriesByThread,
     },
     media: {
       getByPostIds: async () => opts.mediaByPost,
@@ -170,7 +171,7 @@ describe("export → import round-trip", () => {
         ["post-root", [rootMedia]],
         ["post-reply", [replyMedia]],
       ]),
-      collectionEntriesByPost: entries,
+      collectionEntriesByThread: entries,
       aliasMap: new Map([["post-root", ["/historic-slug/"]]]),
     });
     const exportService = createExportService(services, makeSiteConfig());
@@ -220,6 +221,7 @@ describe("export → import round-trip", () => {
     // Reply bundle carries build.render: never and its own media entries.
     const replyFm = rootBundle.children[0].frontMatter;
     expect(replyFm.build).toEqual({ render: "never", list: "local" });
+    expect(replyFm.collections).toBeUndefined();
     expect(replyFm.media?.[0].src).toBe("/media/med-reply.webp");
     expect(replyFm.media?.[0].alt).toBe("Detail");
 

package/src/__tests__/export-service.test.ts

@@ -26,7 +26,7 @@ interface FixtureOptions {
   posts: Post[];
   collections?: Collection[];
   collectionsByPost?: Map<string, Collection[]>;
-  collectionEntriesByPost?: Map<
+  collectionEntriesByThread?: Map<
     string,
     {
       collectionId: string;
@@ -47,7 +47,7 @@ function buildServices(opts: FixtureOptions): ServicesArg {
     posts,
     collections = [],
     collectionsByPost = new Map(),
-    collectionEntriesByPost = new Map(),
+    collectionEntriesByThread = new Map(),
     mediaByPost = new Map(),
     slugMap = new Map(posts.map((p) => [p.id, p.slug])),
     aliasMap = new Map(),
@@ -75,14 +75,14 @@ function buildServices(opts: FixtureOptions): ServicesArg {
             type: "collection" as const,
             collection: {
               ...collection,
-              postCount: 0,
+              threadCount: 0,
               recentActivityAt: collection.updatedAt,
             },
           })),
         directoryItems: [],
       }),
       getCollectionsByPostIds: async () => collectionsByPost,
-      getCollectionEntriesByPostIds: async () => collectionEntriesByPost,
+      getCollectionEntriesByThreadIds: async () => collectionEntriesByThread,
     },
     media: {
       getByPostIds: async () => mediaByPost,
@@ -123,7 +123,7 @@ describe("createExportService (Hugo)", () => {
     // Starts with YAML delimiter
     expect(text.startsWith("---\n")).toBe(true);
 
-    // Stable key order: id, title, date, slug, type, featured_at, pinned_at
+    // Stable key order: Post fields, Featured projection, then pin metadata.
     const headerLines = text
       .split("\n")
       .slice(1, text.split("\n").indexOf("---", 1))
@@ -139,6 +139,8 @@ describe("createExportService (Hugo)", () => {
       "visibility",
       "summary_text",
       "featured_at",
+      "featured_post_ids",
+      "featured_sort_at",
       "pinned_at",
     ];
     let cursor = -1;
@@ -156,6 +158,10 @@ describe("createExportService (Hugo)", () => {
     expect(frontMatter.featured_at).toBe(
       new Date(1773100000 * 1000).toISOString(),
     );
+    expect(frontMatter.featured_post_ids).toEqual(["post-root"]);
+    expect(frontMatter.featured_sort_at).toBe(
+      new Date((root.publishedAt ?? root.createdAt) * 1000).toISOString(),
+    );
     expect(frontMatter.pinned_at).toBe(
       new Date(1773200000 * 1000).toISOString(),
     );
@@ -204,6 +210,47 @@ describe("createExportService (Hugo)", () => {
     expect(replyFm.id).toBe("post-reply");
   });
 
+  it("projects Child Featured selection and publication order onto the Root bundle", async () => {
+    const root = makePost({
+      id: "post-root",
+      slug: "thread-root",
+      threadId: "post-root",
+      publishedAt: 1000,
+      createdAt: 1000,
+    });
+    const featuredReply = makePost({
+      id: "post-featured-reply",
+      slug: "featured-reply",
+      replyToId: root.id,
+      threadId: root.id,
+      featuredAt: 9000,
+      publishedAt: 3000,
+      createdAt: 3000,
+    });
+    const finalReply = makePost({
+      id: "post-final-reply",
+      slug: "final-reply",
+      replyToId: featuredReply.id,
+      threadId: root.id,
+      publishedAt: 4000,
+      createdAt: 4000,
+    });
+
+    const service = createExportService(
+      buildServices({ posts: [root, featuredReply, finalReply] }),
+      makeSiteConfig(),
+    );
+    const files = filesToMap(await service.generateHugoFiles());
+    const rootText = files.get("content/thread-root/_index.md") as string;
+    const { frontMatter } = await parseFrontMatter(rootText);
+
+    expect(frontMatter.featured_at).toBeUndefined();
+    expect(frontMatter.featured_post_ids).toEqual([featuredReply.id]);
+    expect(frontMatter.featured_sort_at).toBe(
+      new Date(3000 * 1000).toISOString(),
+    );
+  });
+
   it("merges historical root aliases + reply slugs onto the root", async () => {
     const root = makePost({ id: "r", slug: "new-slug", threadId: "r" });
     const reply = makePost({
@@ -354,6 +401,56 @@ describe("createExportService (Hugo)", () => {
     }
   });
 
+  it("disables all Hugo feed outputs and hides only system RSS navigation", async () => {
+    const collection = makeCollection({ id: "col-1", slug: "ideas" });
+    const service = createExportService(
+      buildServices({ posts: [], collections: [collection] }),
+      makeSiteConfig({
+        publicApiEnabled: false,
+        rssFeedsEnabled: false,
+        navItems: [
+          {
+            type: "system",
+            systemKey: "rss",
+            label: "System feed",
+            url: "/feed",
+            position: 0,
+            placement: "header",
+          },
+          {
+            type: "link",
+            systemKey: null,
+            label: "Custom feed",
+            url: "/feed",
+            position: 1,
+            placement: "header",
+          },
+        ],
+      }),
+    );
+    const files = filesToMap(await service.generateHugoFiles());
+    const toml = files.get("hugo.toml") as string;
+    const data = files.get("data/jant.toml") as string;
+
+    expect(toml).toMatch(/\[outputs\][\s\S]*home = \[\s*"html"\s*\]/);
+    expect(toml).toContain("public_api_enabled = false");
+    expect(toml).toContain("rss_feeds_enabled = false");
+    expect(data).toContain("public_api_enabled = false");
+    expect(data).toContain("rss_feeds_enabled = false");
+    expect(data).not.toContain('label = "System feed"');
+    expect(data).toContain('label = "Custom feed"');
+
+    for (const path of [
+      "content/featured/_index.md",
+      "content/archive/_index.md",
+      "content/ideas/_index.md",
+    ]) {
+      const raw = files.get(path) as string;
+      const { frontMatter } = await parseFrontMatter(raw);
+      expect(frontMatter.outputs).toEqual(["html"]);
+    }
+  });
+
   it("resolves the nav RSS link to /featured/index.xml when mainRssFeed=featured", async () => {
     const service = createExportService(
       buildServices({ posts: [] }),
@@ -445,7 +542,7 @@ describe("createExportService (Hugo)", () => {
             type: "collection" as const,
             collection: {
               ...collection,
-              postCount: 0,
+              threadCount: 0,
               recentActivityAt: collection.updatedAt,
             },
           },
@@ -510,6 +607,7 @@ describe("createExportService (Hugo)", () => {
       "themes/jant/layouts/partials/pagination.html",
       "themes/jant/layouts/partials/post-card.html",
       "themes/jant/layouts/partials/reply.html",
+      "themes/jant/layouts/partials/featured-thread.html",
       "themes/jant/layouts/partials/feed-post-content.xml",
     ];
     for (const path of expectedLayouts) {
@@ -520,6 +618,31 @@ describe("createExportService (Hugo)", () => {
     expect(files.has("themes/jant/static/tokens.css")).toBe(true);
     expect(files.has("themes/jant/static/theme.css")).toBe(true);
     expect(files.has("themes/jant/static/custom.css")).toBe(true);
+
+    const collectionList = files.get(
+      "themes/jant/layouts/_default/list.html",
+    ) as string;
+    expect(collectionList).toContain(
+      'class="thread thread-full{{ if $hasReplies }} thread-has-replies{{ end }}"',
+    );
+  });
+
+  it("renders semantic, namespaced footnotes in exported site HTML fields", async () => {
+    const service = createExportService(
+      buildServices({ posts: [] }),
+      makeSiteConfig({
+        siteFooter: "Footer[^1]\n\n[^1]: Export definition",
+      }),
+    );
+    const files = filesToMap(await service.generateHugoFiles());
+    const { parse } = await import("smol-toml");
+    const data = parse(files.get("data/jant.toml") as string);
+    const footerHtml = data.site_footer_html as string;
+
+    expect(footerHtml).toContain('role="doc-noteref"');
+    expect(footerHtml).toContain('role="doc-endnotes"');
+    expect(footerHtml).toContain("fn-3gu8g1hux2k2m-1");
+    expect(footerHtml).not.toContain("site-footer");
   });
 
   it("writes a .gitignore covering Hugo build artifacts", async () => {
@@ -550,9 +673,15 @@ describe("createExportService (Hugo)", () => {
     expect(Object.keys(decoded)).toContain("hugo.toml");
   });
 
-  it("round-trips collection memberships on each post's front matter", async () => {
+  it("writes Thread collection memberships only on root front matter", async () => {
     const collection = makeCollection({ id: "col-1", slug: "ideas" });
     const root = makePost({ id: "post-root", slug: "entry-a" });
+    const reply = makePost({
+      id: "post-reply",
+      slug: "entry-a-reply",
+      replyToId: "post-root",
+      threadId: "post-root",
+    });
     const entries = new Map<
       string,
       {
@@ -572,9 +701,9 @@ describe("createExportService (Hugo)", () => {
     ]);
     const service = createExportService(
       buildServices({
-        posts: [root],
+        posts: [root, reply],
         collections: [collection],
-        collectionEntriesByPost: entries,
+        collectionEntriesByThread: entries,
       }),
       makeSiteConfig(),
     );
@@ -591,6 +720,10 @@ describe("createExportService (Hugo)", () => {
         pinned_at: new Date(1773050000 * 1000).toISOString(),
       },
     ]);
+    const { frontMatter: replyFrontMatter } = await parseFrontMatter(
+      files.get("content/entry-a/entry-a-reply/index.md") as string,
+    );
+    expect(replyFrontMatter.collections).toBeUndefined();
   });
 
   it("emits media[] front matter for each attachment on a post", async () => {

package/src/__tests__/helpers/app.ts

@@ -43,6 +43,8 @@ interface TestAppOptions {
   telegramBotTokens?: string;
   /** Optional `TELEGRAM_WEBHOOK_SECRET` env binding for Telegram webhook tests */
   telegramWebhookSecret?: string;
+  /** RSS publication delay; defaults to zero in general route tests. */
+  rssPublishDelaySeconds?: number;
 }
 
 /**
@@ -84,6 +86,7 @@ export function createTestApp(options: TestAppOptions = {}) {
       HOSTED_CONTROL_PLANE_SSO_SECRET: options.hostedControlPlaneSsoSecret,
       TELEGRAM_BOT_TOKENS: options.telegramBotTokens,
       TELEGRAM_WEBHOOK_SECRET: options.telegramWebhookSecret,
+      RSS_PUBLISH_DELAY_SECONDS: options.rssPublishDelaySeconds ?? 0,
       NODE_DATABASE: {
         db,
         dialect: "sqlite",