@jant/core 0.6.16 → 0.7.0

package/dist/index.js

@@ -1,6 +1,3 @@
-import { b as url_exports } from "./url-CbLAtlZe.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-C7_4oab9.js";
-import { B as NAV_ITEM_TYPES, E as time_exports, F as MAX_MEDIA_ATTACHMENTS, H as STATUSES, I as MAX_PINNED_POSTS, K as TEXT_ATTACHMENT_CONTENT_FORMATS, N as FORMATS, V as SORT_ORDERS, s as markdown_exports, z as MEDIA_KINDS } from "./export-Dl5KCiEs.js";
-import "./env-BPYViDJJ.js";
-import "./github-sync-HdK2EgvJ.js";
+import { Fn as url_exports, Ht as STATUSES, Kt as TEXT_ATTACHMENT_CONTENT_FORMATS, Mt as MEDIA_KINDS, Ot as MAX_MEDIA_ATTACHMENTS, Pt as NAV_ITEM_TYPES, R as time_exports, Vt as SORT_ORDERS, kt as MAX_PINNED_POSTS, v as markdown_exports, wt as FORMATS } from "./github-sync-BPAvT999.js";
+import { C as toNavItemViews, E as toSearchResultView, S as toNavItemView, T as toPostViews, _ as defaultFeedRenderer, b as toArchiveGroupsWithMedia, n as createApp, v as createMediaContext, w as toPostView, x as toMediaView, y as toArchiveGroups } from "./app-K_Aa1MMn.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,5 @@
-import "./url-CbLAtlZe.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-C7_4oab9.js";
-import { t as createExportService } from "./export-Dl5KCiEs.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-BPYViDJJ.js";
-import "./github-sync-HdK2EgvJ.js";
+import { $ as getHostedControlPlaneBaseUrl, H as getConfiguredSingleSiteOrigin, U as getConfiguredSingleSitePathPrefix, Z as getEnvString, ct as getSiteResolutionMode, dt as shouldTrustProxy, lt as getTelegramBotPool, s as createExportService, st as getPort, ut as getTelegramWebhookSecret } from "./github-sync-BPAvT999.js";
+import { A as resolveCjkFontProfile, D as BUILTIN_FONT_THEMES, M as BUILTIN_COLOR_THEMES, N as getPublicAssetBasePath, O as getCjkFontCssVariables, P as isAssetPath, a as createSiteService, c as resolveConfig, d as setWebhook, f as createStorageDriver, g as schema_exports, h as createNodeDatabase, i as createNodeRequestRuntime, j as buildThemeStyle, k as getFontThemeCssVariables, l as getWebhookUrl, m as sqliteSchemaBundle, n as createApp, o as getHostBasedStartupConfigurationIssues, p as pgSchemaBundle, r as createNodeCliRuntime, s as resolveDatabaseDialect, u as setMyCommands } from "./app-K_Aa1MMn.js";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { serve } from "@hono/node-server";
 import Database from "better-sqlite3";
@@ -422,7 +419,8 @@ async function migrate(env = getProcessBindings()) {
 	}
 	const sqlite = createNodeSqlite(env, { createParentDir: true });
 	try {
-		migrate$1(drizzle(sqlite, { schema: schema_exports }), { migrationsFolder: resolveNodeMigrationsDir(import.meta.url, "sqlite") });
+		const db = drizzle(sqlite, { schema: schema_exports });
+		migrate$1(db, { migrationsFolder: resolveNodeMigrationsDir(import.meta.url, "sqlite") });
 	} finally {
 		sqlite.close();
 	}
@@ -529,7 +527,7 @@ async function createNodeRequestHandler(options) {
 async function start(env = process.env, app) {
 	const handler = await createNodeRequestHandler({
 		env,
-		app: async () => app ?? (await import("./app-C75Zc8dD.js")).createApp()
+		app: async () => app ?? (await import("./app-K_Aa1MMn.js").then((n) => n.t)).createApp()
 	});
 	const hostname = resolveHost(env);
 	const port = resolvePort(env);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jant/core",
-  "version": "0.6.16",
+  "version": "0.7.0",
   "description": "A modern, open-source microblogging platform built on Cloudflare Workers",
   "type": "module",
   "exports": {
@@ -48,7 +48,7 @@
     "@tiptap/starter-kit": "^3.27.3",
     "@tiptap/suggestion": "^3.27.3",
     "basecoat-css": "^0.3.11",
-    "better-auth": "^1.5.5",
+    "better-auth": "1.6.27",
     "better-sqlite3": "^12.8.0",
     "blurhash": "^2.0.5",
     "drizzle-orm": "^0.45.1",
@@ -90,7 +90,7 @@
     "@lingui/conf": "^5.9.3",
     "@lingui/format-po": "^5.9.3",
     "@lingui/swc-plugin": "^5.11.0",
-    "@swc/core": "^1.15.18",
+    "@swc/core": "1.15.47",
     "@tailwindcss/vite": "^4.2.2",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.5.0",

package/src/__tests__/auth-session-freshness.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { eq } from "drizzle-orm";
+import { createAuth } from "../auth.js";
+import { createTestDatabase } from "./helpers/db.js";
+import { session as sessionTable } from "../db/schema.js";
+
+/**
+ * better-auth gates `list-sessions` behind a "fresh session" check whose
+ * default window is 24 hours, measured from `session.createdAt` — a value
+ * renewal never moves. Jant deliberately runs 90-day rolling sessions, so
+ * without `freshAge: 0` the Sessions page answers "Session is not fresh"
+ * forever from the second day of a sign-in onwards.
+ */
+async function signUpAndGetCookie(auth: ReturnType<typeof createAuth>) {
+  const signUp = await auth.api.signUpEmail({
+    body: {
+      name: "Owner",
+      email: "owner@example.com",
+      password: "correct-horse-battery",
+    },
+    returnHeaders: true,
+  });
+  const token = signUp.headers
+    .getSetCookie()
+    .find((cookie) => cookie.includes(".session_token="));
+  expect(token).toBeDefined();
+  // Send only the session token, not the `session_data` cache cookie: a cache
+  // hit short-circuits before the database read this test is about.
+  return token!.split(";")[0]!;
+}
+
+describe("session freshness", () => {
+  it("lists sessions that are older than better-auth's default fresh window", async () => {
+    const { db } = createTestDatabase();
+    const auth = createAuth(db, {
+      secret: "test-secret-with-enough-entropy-for-session-cookies",
+      baseURL: "https://example.com",
+      useSecureCookies: true,
+    });
+    const cookie = await signUpAndGetCookie(auth);
+
+    const [row] = await db.select().from(sessionTable);
+    expect(row).toBeDefined();
+    // Two days old: past the 24-hour default, well inside the 90-day window.
+    await db
+      .update(sessionTable)
+      .set({ createdAt: new Date(Date.now() - 2 * 24 * 60 * 60 * 1000) })
+      .where(eq(sessionTable.id, row!.id));
+
+    const sessions = await auth.api.listSessions({
+      headers: new Headers({ cookie }),
+    });
+
+    expect(sessions).toHaveLength(1);
+    expect(sessions[0]!.token).toBe(row!.token);
+  });
+});

package/src/__tests__/basecoat-variants.test.ts

@@ -0,0 +1,121 @@
+/**
+ * BaseCoat variant classes are self-contained, and this is what says so out
+ * loud.
+ *
+ * AGENTS.md has carried the rule under Hard Constraints all along and it was
+ * broken anyway, more than once, because nothing failed when it was: the markup
+ * compiles, every other test passes, and the damage is visible only to an eye
+ * looking at the right pixel.
+ *
+ * What `class="btn btn-outline"` does, exactly: both are single-class
+ * selectors, so specificity ties and source order decides. `.btn-outline` is
+ * declared later, so its `bg-background` wins the background — but it sets no
+ * text colour, so `.btn`'s `text-primary-foreground` survives. A light label on
+ * a light fill: the button reads as empty until `:hover`, where
+ * `.btn-outline:hover` sets `text-accent-foreground` and the words appear. Each
+ * pairing fails for its own reason, which is why the rule is "never combine"
+ * rather than a list of bad pairs.
+ */
+
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+
+const SRC_DIR = fileURLToPath(new URL("..", import.meta.url));
+
+/**
+ * The BaseCoat families whose variants replace the base class rather than
+ * modify it. Anything of the form `<base>-<x>` is one of `<base>`'s variants.
+ */
+const FAMILIES = ["btn", "badge", "alert"];
+
+/** Class attributes as authored — JSX `className="…"` and Lit `class="…"` alike. */
+const CLASS_ATTR = /\bclass(?:Name)?="([^"]*)"/g;
+
+/**
+ * Walk the source tree for authored markup.
+ *
+ * @param dir - Directory to descend into
+ * @returns Absolute paths of every `.ts`/`.tsx` file outside tests
+ */
+function collectSourceFiles(dir: string): string[] {
+  const found: string[] = [];
+  for (const entry of readdirSync(dir)) {
+    const path = join(dir, entry);
+    if (statSync(path).isDirectory()) {
+      if (entry === "__tests__" || entry === "node_modules") continue;
+      found.push(...collectSourceFiles(path));
+    } else if (entry.endsWith(".ts") || entry.endsWith(".tsx")) {
+      found.push(path);
+    }
+  }
+  return found;
+}
+
+/**
+ * Every class attribute in the repo's own markup, with the file it came from.
+ *
+ * A `class` built by interpolation is read for its literal words only. That is
+ * the point rather than a limitation: the pairing this guards against is
+ * written literally, and a regex should not try to evaluate a template.
+ *
+ * @returns One entry per class attribute found
+ */
+function readClassAttributes(): Array<{ file: string; classes: string[] }> {
+  const found: Array<{ file: string; classes: string[] }> = [];
+
+  for (const file of collectSourceFiles(SRC_DIR)) {
+    const source = readFileSync(file, "utf8");
+    for (const match of source.matchAll(CLASS_ATTR)) {
+      found.push({
+        file: file.slice(SRC_DIR.length),
+        classes: (match[1] ?? "").split(/\s+/).filter(Boolean),
+      });
+    }
+  }
+
+  return found;
+}
+
+describe("BaseCoat variant classes", () => {
+  it("are never combined with their base class", () => {
+    const offenders: string[] = [];
+
+    for (const { file, classes } of readClassAttributes()) {
+      for (const base of FAMILIES) {
+        if (!classes.includes(base)) continue;
+        const variant = classes.find(
+          (name) => name !== base && name.startsWith(`${base}-`),
+        );
+        if (variant) {
+          offenders.push(`${file}: class="… ${base} ${variant} …"`);
+        }
+      }
+    }
+
+    expect(
+      offenders,
+      [
+        "A BaseCoat variant replaces the base class, it does not modify it.",
+        "Drop the bare base and keep the variant alone:",
+        ...offenders,
+      ].join("\n"),
+    ).toEqual([]);
+  });
+
+  // A guard is worth nothing if the shape it looks for is not the shape the
+  // markup writes, so this pins the reader against real files rather than
+  // trusting the regex.
+  it("reads class attributes out of the real markup", () => {
+    const attributes = readClassAttributes();
+
+    expect(attributes.length).toBeGreaterThan(100);
+    expect(attributes.some(({ classes }) => classes.includes("btn"))).toBe(
+      true,
+    );
+    expect(
+      attributes.some(({ classes }) => classes.includes("btn-outline")),
+    ).toBe(true);
+  });
+});

package/src/__tests__/bin/assets-upload.test.ts

@@ -0,0 +1,68 @@
+import { brotliDecompressSync } from "node:zlib";
+import { describe, expect, it } from "vitest";
+import { compressForUpload } from "../../../bin/commands/assets/upload.js";
+
+describe("compressForUpload", () => {
+  it("compresses text assets and round-trips them unchanged", () => {
+    // Repetitive like real CSS, so brotli has something to work with.
+    const body = Buffer.from(
+      ".a{color:var(--site-text-primary)}".repeat(200),
+      "utf8",
+    );
+
+    const packed = compressForUpload("client.css", body);
+
+    expect(packed).not.toBeNull();
+    expect(packed!.length).toBeLessThan(body.length);
+    expect(brotliDecompressSync(packed!).equals(body)).toBe(true);
+  });
+
+  it("leaves already-compressed types alone", () => {
+    // Running brotli over a woff2 or a png costs build time and usually grows
+    // the file; the CDN would then serve a needless encoding header too.
+    const body = Buffer.from("x".repeat(5000), "utf8");
+
+    for (const name of ["font.woff2", "logo.png", "icon.ico", "photo.jpg"]) {
+      expect(compressForUpload(name, body)).toBeNull();
+    }
+  });
+
+  it("falls back to the raw body when compression does not shrink it", () => {
+    // A few random bytes come back larger once the brotli header is added.
+    const body = Buffer.from([0x1f, 0x2e, 0x3d, 0x4c]);
+
+    expect(compressForUpload("tiny.json", body)).toBeNull();
+  });
+
+  it("matches on the extension case-insensitively", () => {
+    const body = Buffer.from("body{margin:0}".repeat(200), "utf8");
+
+    expect(compressForUpload("STYLE.CSS", body)).not.toBeNull();
+  });
+});
+
+describe("stale encoding detection", () => {
+  // `findStaleEncodingKeys` is not exported — it needs a live S3 client — so
+  // these pin the decision it is built on: which files we expect to find
+  // stored as brotli, and which correctly have no `Content-Encoding`.
+  it("expects compression for the types that carry the reader payload", () => {
+    const body = Buffer.from(".x{color:red}".repeat(400), "utf8");
+
+    // A CJK stylesheet is the case that motivated this: its key never changes,
+    // so it was skipped forever and kept being compressed at the CDN's own low
+    // quality on every request.
+    for (const name of ["client-cjk-B7Z0snDu.css", "client-CDPZMBLo.js"]) {
+      expect(compressForUpload(name, body)).not.toBeNull();
+    }
+  });
+
+  it("expects no compression where storing raw is the right answer", () => {
+    // Anything here would be re-uploaded on every run if a missing
+    // `Content-Encoding` counted as stale.
+    const dense = Buffer.from("y".repeat(4000), "utf8");
+    expect(compressForUpload("subset.woff2", dense)).toBeNull();
+
+    const tiny = Buffer.from([0x7a, 0x1b, 0x4f, 0x22]);
+    expect(compressForUpload("meta.json", tiny)).toBeNull();
+  });
+});

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

@@ -196,6 +196,9 @@ describe("Hugo smoke build", () => {
       "public/hello-world/index.html",
       // Alias page for the reply slug (root aliases include /hello-reply/).
       "public/hello-reply/index.html",
+      // The feed redirects are useless unless Hugo copies them to the root of
+      // the published directory, where Cloudflare Pages and Netlify look.
+      "public/_redirects",
     ]) {
       expect(await fileExists(join(tempDir, rel)), `missing ${rel}`).toBe(true);
     }
@@ -218,6 +221,32 @@ describe("Hugo smoke build", () => {
     expect(collectionFeed).toContain("Follow-up");
     expect(collectionFeed.match(/<entry>/g)).toHaveLength(1);
 
+    // The exported feed carries the same entry payload the served one does,
+    // minus what Known Limits in docs/internal/feed-contract.md records. A
+    // template that stops compiling these silently drops them from every
+    // self-hosted export.
+    expect(collectionFeed).toContain('xmlns:jant="https://jant.me/ns"');
+    expect(collectionFeed).toContain(
+      'xmlns:media="http://search.yahoo.com/mrss/"',
+    );
+    expect(collectionFeed).toContain("<jant:format>note</jant:format>");
+    // Nothing in this thread is cut, so the flag stays absent.
+    expect(collectionFeed).not.toContain("<jant:truncated/>");
+    expect(collectionFeed).toContain(
+      '<category term="ideas" label="Ideas" jant:page="https://example.com/ideas/"/>',
+    );
+    // Media RSS describes the attachment; the content shows it in the same
+    // `data-post-media` container the site marks its gallery strip with.
+    expect(collectionFeed).toContain('medium="image"');
+    expect(collectionFeed).toContain('width="800" height="600"');
+    expect(collectionFeed).toContain(
+      '<media:description type="plain">A photo</media:description>',
+    );
+    expect(collectionFeed).toContain("<div data-post-media>");
+    // An image is already shown full size inside a link to the original, so it
+    // gets no enclosure.
+    expect(collectionFeed).not.toContain('rel="enclosure"');
+
     const featuredHtml = await readFile(
       join(tempDir, "public/featured/index.html"),
       "utf-8",
@@ -234,4 +263,235 @@ describe("Hugo smoke build", () => {
     expect(featuredFeed).toContain("Follow-up");
     expect(featuredFeed.match(/<entry>/g)).toHaveLength(1);
   }, 60_000);
+
+  // Two feed details the served feed gets right and the template has to
+  // match by hand: author text inside an attribute, and the entry-level
+  // truncation flag on a thread.
+  it("escapes image alt in the feed and marks a thread truncated by a folded-in reply", async () => {
+    if (!hugoOk) {
+      console.log("hugo binary not found on PATH — skipping hugo build test");
+      return;
+    }
+
+    const para = (text: string) => ({
+      type: "paragraph",
+      content: [{ type: "text", text }],
+    });
+    const root = makePost({
+      id: "pst_blue",
+      slug: "blue-room",
+      title: "The blue room",
+      threadId: "pst_blue",
+    });
+    // The leading reply is cut by the timeline; the newest is not. The old
+    // rule looked only at the newest reply and would have left the entry
+    // unmarked. A titleless note is cut at NOTE_SUMMARY_MAX_CHARS with at
+    // least NOTE_SUMMARY_MIN_HIDDEN_CHARS left over, so four long paragraphs.
+    const longReply = makePost({
+      id: "pst_long",
+      slug: "blue-long",
+      title: null,
+      replyToId: "pst_blue",
+      threadId: "pst_blue",
+      createdAt: 1773020000,
+      publishedAt: 1773020000,
+      body: JSON.stringify({
+        type: "doc",
+        content: ["Alpha", "Beta", "Gamma", "Omega"].map((word) =>
+          para(`${word} `.repeat(90).trim()),
+        ),
+      }),
+    });
+    const shortReply = makePost({
+      id: "pst_short",
+      slug: "blue-short",
+      title: null,
+      replyToId: "pst_blue",
+      threadId: "pst_blue",
+      createdAt: 1773030000,
+      publishedAt: 1773030000,
+      body: JSON.stringify({ type: "doc", content: [para("Short enough.")] }),
+    });
+    // A quote and a backslash: Go's `%q` would turn both into `\"` and `\\`.
+    const alt = 'The "Blue" room, C:\\photos';
+    const media = makeMedia({ id: "med_blue", filename: "blue.webp", alt });
+
+    const services = {
+      posts: { list: async () => [root, longReply, shortReply] },
+      paths: {
+        getPostSlugMap: async () =>
+          new Map([
+            ["pst_blue", "blue-room"],
+            ["pst_long", "blue-long"],
+            ["pst_short", "blue-short"],
+          ]),
+        getPostAliases: async () => new Map(),
+        getCollectionSlugMap: async () => new Map(),
+      },
+      collections: {
+        list: async () => [],
+        listDirectoryData: async () => ({
+          collections: [],
+          items: [],
+          directoryItems: [],
+        }),
+        getCollectionsByPostIds: async () => new Map(),
+        getCollectionEntriesByThreadIds: async () => new Map(),
+      },
+      media: {
+        getByPostIds: async () => new Map([["pst_blue", [media]]]),
+      },
+    } as unknown as ServicesArg;
+
+    const siteDir = await mkdtemp(join(tmpdir(), "jant-hugo-feed-"));
+    try {
+      const files = await createExportService(
+        services,
+        makeSiteConfig(),
+      ).generateHugoFiles();
+      for (const file of files) {
+        const target = join(siteDir, file.path);
+        await mkdir(dirname(target), { recursive: true });
+        const data =
+          typeof file.content === "string"
+            ? new TextEncoder().encode(file.content)
+            : file.content;
+        await writeFile(target, data);
+      }
+      await writeFile(
+        join(siteDir, "content/blue-room/med_blue.webp"),
+        "PHOTO",
+      );
+
+      const { code, stdout, stderr } = await runHugo(siteDir);
+      if (code !== 0) {
+        console.error("hugo stdout:", stdout);
+        console.error("hugo stderr:", stderr);
+      }
+      expect(code).toBe(0);
+      expect(stderr).not.toMatch(/\bERROR\b/);
+
+      const feed = await readFile(join(siteDir, "public/index.xml"), "utf-8");
+      expect(feed.match(/<entry>/g)).toHaveLength(1);
+
+      // The attribute is XML-escaped like the caption next to it, not
+      // Go-quoted: `"` becomes a character reference and `\` stays itself.
+      const escapedAlt = "The &#34;Blue&#34; room, C:\\photos";
+      expect(feed).toContain(`alt="${escapedAlt}"`);
+      expect(feed).toContain(`<figcaption>${escapedAlt}</figcaption>`);
+      expect(feed).not.toContain('alt="The \\"');
+
+      expect(feed).toContain("<jant:truncated/>");
+    } finally {
+      await rm(siteDir, { recursive: true, force: true });
+    }
+  }, 60_000);
+
+  it("folds a long thread's preview the way the site does", async () => {
+    if (!hugoOk) {
+      console.log("hugo binary not found on PATH — skipping hugo build test");
+      return;
+    }
+
+    const words = ["one", "two", "three", "four", "five", "six", "seven"];
+    const root = makePost({
+      id: "pst_fold",
+      slug: "fold-root",
+      title: "A long thread",
+      threadId: "pst_fold",
+    });
+    const replies = words.map((word, index) =>
+      makePost({
+        id: `pst_fold_${word}`,
+        slug: `fold-${word}`,
+        title: null,
+        replyToId: "pst_fold",
+        threadId: "pst_fold",
+        createdAt: 1773020000 + index * 1000,
+        publishedAt: 1773020000 + index * 1000,
+        body: JSON.stringify({
+          type: "doc",
+          content: [
+            {
+              type: "paragraph",
+              content: [{ type: "text", text: `Reply ${word} of the fold.` }],
+            },
+          ],
+        }),
+      }),
+    );
+
+    const services = {
+      posts: { list: async () => [root, ...replies] },
+      paths: {
+        getPostSlugMap: async () =>
+          new Map([
+            ["pst_fold", "fold-root"],
+            ...words.map((word): [string, string] => [
+              `pst_fold_${word}`,
+              `fold-${word}`,
+            ]),
+          ]),
+        getPostAliases: async () => new Map(),
+        getCollectionSlugMap: async () => new Map(),
+      },
+      collections: {
+        list: async () => [],
+        listDirectoryData: async () => ({
+          collections: [],
+          items: [],
+          directoryItems: [],
+        }),
+        getCollectionsByPostIds: async () => new Map(),
+        getCollectionEntriesByThreadIds: async () => new Map(),
+      },
+      media: { getByPostIds: async () => new Map() },
+    } as unknown as ServicesArg;
+
+    const siteDir = await mkdtemp(join(tmpdir(), "jant-hugo-fold-"));
+    try {
+      const files = await createExportService(
+        services,
+        makeSiteConfig(),
+      ).generateHugoFiles();
+      for (const file of files) {
+        const target = join(siteDir, file.path);
+        await mkdir(dirname(target), { recursive: true });
+        const data =
+          typeof file.content === "string"
+            ? new TextEncoder().encode(file.content)
+            : file.content;
+        await writeFile(target, data);
+      }
+
+      const { code, stdout, stderr } = await runHugo(siteDir);
+      if (code !== 0) {
+        console.error("hugo stdout:", stdout);
+        console.error("hugo stderr:", stderr);
+      }
+      expect(code).toBe(0);
+
+      const html = await readFile(join(siteDir, "public/index.html"), "utf-8");
+      // Core's fold: the first two replies, a gap, the two before the newest,
+      // and the newest as the hero. Seven replies hide two.
+      for (const shown of ["one", "two", "five", "six", "seven"]) {
+        expect(html).toContain(`Reply ${shown} of the fold.`);
+      }
+      for (const hidden of ["three", "four"]) {
+        expect(html).not.toContain(`Reply ${hidden} of the fold.`);
+      }
+      expect(html).toContain("2 more posts");
+      // The gap leads to the first hidden reply, as the site's does. The
+      // build is minified, so attribute quotes are not guaranteed.
+      expect(html).toMatch(/thread-preview-gap"? href="?[^" >]*\/fold-three\//);
+      // A reply's card links to the reply's own address — its alias on the
+      // root — not to an empty href, since reply pages are never rendered.
+      expect(html).toMatch(
+        /post-card-permalink"? href="?[^" >]*\/fold-seven\//,
+      );
+      expect(html).not.toMatch(/post-card-permalink"? href(?=[ >])/);
+    } finally {
+      await rm(siteDir, { recursive: true, force: true });
+    }
+  }, 60_000);
 });