@jant/core 0.7.0 → 0.7.1

package/dist/index.js

@@ -1,3 +1,3 @@
-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";
+import { At as MAX_PINNED_POSTS, Ft as NAV_ITEM_TYPES, Ht as SORT_ORDERS, Ln as url_exports, Nt as MEDIA_KINDS, Tt as FORMATS, Ut as STATUSES, kt as MAX_MEDIA_ATTACHMENTS, qt as TEXT_ATTACHMENT_CONTENT_FORMATS, v as markdown_exports, z as time_exports } from "./github-sync-Gw4orAHk.js";
+import { C as toNavItemView, D as toSearchResultView, E as toPostViews, S as toMediaView, T as toPostView, b as toArchiveGroups, n as createApp, v as defaultFeedRenderer, w as toNavItemViews, x as toArchiveGroupsWithMedia, y as createMediaContext } from "./app-ZcaI1kPN.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,5 +1,5 @@
-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 { K as getConfiguredStorageDriver, Q as getEnvString, R as now, U as getConfiguredSingleSiteOrigin, W as getConfiguredSingleSitePathPrefix, ct as getPort, dt as getTelegramWebhookSecret, et as getHostedControlPlaneBaseUrl, ft as shouldTrustProxy, lt as getSiteResolutionMode, s as createExportService, ut as getTelegramBotPool } from "./github-sync-Gw4orAHk.js";
+import { A as getFontThemeCssVariables, F as isAssetPath, M as buildThemeStyle, N as BUILTIN_COLOR_THEMES, O as BUILTIN_FONT_THEMES, P as getPublicAssetBasePath, _ as schema_exports, a as setUpNodeInstance, c as resolveDatabaseDialect, d as setMyCommands, f as setWebhook, g as createNodeDatabase, h as sqliteSchemaBundle, i as createNodeRequestRuntime, j as resolveCjkFontProfile, k as getCjkFontCssVariables, l as resolveConfig, m as pgSchemaBundle, n as createApp, o as createSiteService, p as createStorageDriver, r as createNodeCliRuntime, s as getHostBasedStartupConfigurationIssues, u as getWebhookUrl } from "./app-ZcaI1kPN.js";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { serve } from "@hono/node-server";
 import Database from "better-sqlite3";
@@ -440,7 +440,11 @@ async function createNodeRequestHandler(options) {
 	const env = options?.env ?? getProcessBindings();
 	const hostBasedStartupIssues = getHostBasedStartupConfigurationIssues(env);
 	if (hostBasedStartupIssues.length > 0) throw new Error(`Host-based startup configuration is invalid:\n- ${hostBasedStartupIssues.map((issue) => issue.message).join("\n- ")}`);
-	const { bindings, close } = await createNodeBindings(env);
+	const { bindings: databaseBindings, close } = await createNodeBindings(env);
+	const bindings = {
+		...databaseBindings,
+		NODE_STARTED_AT: now()
+	};
 	try {
 		await assertNodeSiteResolutionReady(bindings);
 		const assetRoot = options?.assetRoot === void 0 ? resolveNodeAssetRoot() : options.assetRoot;
@@ -527,7 +531,7 @@ async function createNodeRequestHandler(options) {
 async function start(env = process.env, app) {
 	const handler = await createNodeRequestHandler({
 		env,
-		app: async () => app ?? (await import("./app-K_Aa1MMn.js").then((n) => n.t)).createApp()
+		app: async () => app ?? (await import("./app-ZcaI1kPN.js").then((n) => n.t)).createApp()
 	});
 	const hostname = resolveHost(env);
 	const port = resolvePort(env);
@@ -572,4 +576,4 @@ async function start(env = process.env, app) {
 	});
 }
 //#endregion
-export { BUILTIN_COLOR_THEMES, BUILTIN_FONT_THEMES, buildThemeStyle, createApp, createExportService, createNodeBindings, createNodeCliRuntime, createNodeRequestHandler, createNodeRequestRuntime, createStorageDriver, getCjkFontCssVariables, getFontThemeCssVariables, migrate, resolveCjkFontProfile, resolveConfig, start };
+export { BUILTIN_COLOR_THEMES, BUILTIN_FONT_THEMES, buildThemeStyle, createApp, createExportService, createNodeBindings, createNodeCliRuntime, createNodeRequestHandler, createNodeRequestRuntime, createStorageDriver, getCjkFontCssVariables, getConfiguredStorageDriver, getFontThemeCssVariables, migrate, resolveCjkFontProfile, resolveConfig, setUpNodeInstance, start };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jant/core",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "A modern, open-source microblogging platform built on Cloudflare Workers",
   "type": "module",
   "exports": {
@@ -38,10 +38,16 @@
     "@lingui/react": "^5.9.3",
     "@tailwindcss/typography": "^0.5.19",
     "@tiptap/core": "^3.27.3",
+    "@tiptap/extension-bold": "^3.31.3",
     "@tiptap/extension-code-block": "^3.27.3",
+    "@tiptap/extension-hard-break": "^3.31.3",
     "@tiptap/extension-image": "^3.27.3",
+    "@tiptap/extension-italic": "^3.31.3",
     "@tiptap/extension-link": "^3.27.3",
+    "@tiptap/extension-list": "^3.31.3",
+    "@tiptap/extension-paragraph": "^3.31.3",
     "@tiptap/extension-placeholder": "^3.27.3",
+    "@tiptap/extension-strike": "^3.31.3",
     "@tiptap/extension-table": "^3.27.3",
     "@tiptap/markdown": "^3.27.3",
     "@tiptap/pm": "^3.27.3",
@@ -51,6 +57,7 @@
     "better-auth": "1.6.27",
     "better-sqlite3": "^12.8.0",
     "blurhash": "^2.0.5",
+    "client-zip": "^2.5.1",
     "drizzle-orm": "^0.45.1",
     "emoji-mart": "^5.6.0",
     "fflate": "^0.8.2",
@@ -73,6 +80,8 @@
     "unist-util-visit": "^5.1.0",
     "uqr": "^0.1.3",
     "yaml": "^2.8.2",
+    "yauzl": "^3.4.0",
+    "yazl": "^3.3.1",
     "zod": "^4.3.6"
   },
   "peerDependencies": {
@@ -95,13 +104,14 @@
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.5.0",
     "@types/pg": "^8.20.0",
+    "@types/yauzl": "^3.4.0",
+    "@types/yazl": "^3.3.1",
     "cn-font-split": "^7.4.1",
     "drizzle-kit": "^0.31.10",
     "glob": "^13.0.6",
     "happy-dom": "^20.8.4",
     "sharp": "^0.34.5",
     "tailwindcss": "^4.2.2",
-    "tsx": "^4.21.0",
     "typescript": "^6.0.2",
     "unplugin-swc": "^1.5.9",
     "vite": "^8.0.0",
@@ -136,7 +146,7 @@
     "build:client": "vite build --config vite.config.client.ts",
     "build:site": "vite build --config vite.config.site.ts",
     "build:lib": "node -e \"const{rmSync,readdirSync,existsSync}=require('fs');if(existsSync('dist'))readdirSync('dist').filter(f=>f!=='client').forEach(f=>rmSync('dist/'+f,{recursive:true,force:true}))\" && vite build --config vite.config.worker.ts",
-    "brand:generate": "tsx dev/scripts/generate-brand-assets.ts",
+    "brand:generate": "node dev/run-script.mjs dev/scripts/generate-brand-assets.ts",
     "typecheck": "tsc -b --noEmit",
     "db:generate": "drizzle-kit generate",
     "db:generate:pg": "drizzle-kit generate --config drizzle.config.pg.ts",

package/src/__tests__/dev-scripts.test.ts

@@ -0,0 +1,203 @@
+/**
+ * Every TypeScript dev script loads, and loads the way its task runs it.
+ *
+ * `db-node-rebuild-demo` and `db-node-load-demo` ran their scripts with tsx,
+ * which hands Node `src/` untransformed. When `lib/filter-dimensions.ts` began
+ * declaring its names with the Lingui macro (539cd1bf), both scripts died on
+ * their import lines — and stayed broken for a month, because nothing in CI
+ * ever loaded a dev script. The scripts now run through `dev/run-script.mjs`,
+ * which compiles `src/` the way the builds do. This file holds both halves:
+ * no task goes around the runner, and every script loads through it.
+ *
+ * Loading is not running. A dev script's work sits behind its default export,
+ * so importing one evaluates every module it reaches — where a missing file, an
+ * untransformed macro, or an undefined `define` global fails — without
+ * resetting a database. That contract is checked here too, before anything is
+ * loaded, because a script that broke it would do its work inside this test.
+ *
+ * What loading cannot see: a named import the module no longer exports. Vite's
+ * runner leaves it `undefined` until the script calls it, so a renamed export
+ * is a type error, and `tsconfig.dev.json` is what catches it.
+ */
+
+import { spawnSync } from "node:child_process";
+import {
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { parse } from "smol-toml";
+import ts from "typescript";
+import { describe, expect, it } from "vitest";
+
+const CORE_DIR = resolve(import.meta.dirname, "../..");
+const REPO_ROOT = resolve(CORE_DIR, "../..");
+const RUNNER = "dev/run-script.mjs";
+
+/** Every TypeScript dev script, relative to the core package. */
+const SCRIPTS = readdirSync(resolve(CORE_DIR, "dev/scripts"))
+  .filter((name) => name.endsWith(".ts"))
+  .sort()
+  .map((name) => `dev/scripts/${name}`);
+
+/** A dev script path as a command names it, with the word before it. */
+const SCRIPT_INVOCATION = /(\S+)\s+(\S*dev\/scripts\/[\w.-]+\.ts)\b/g;
+
+interface MiseConfig {
+  tasks?: Record<string, { run?: string | string[] }>;
+}
+
+/**
+ * Every shell command the repo defines: mise tasks and core's package scripts.
+ *
+ * @returns Each command with the name of the task or script that runs it
+ */
+function collectCommands(): { name: string; command: string }[] {
+  const mise = parse(
+    readFileSync(resolve(REPO_ROOT, "mise.toml"), "utf8"),
+  ) as MiseConfig;
+  const pkg = JSON.parse(
+    readFileSync(resolve(CORE_DIR, "package.json"), "utf8"),
+  ) as { scripts?: Record<string, string> };
+
+  return [
+    ...Object.entries(mise.tasks ?? {}).flatMap(([name, task]) =>
+      [task.run ?? []].flat().map((command) => ({
+        name: `mise task ${name}`,
+        command,
+      })),
+    ),
+    ...Object.entries(pkg.scripts ?? {}).map(([name, command]) => ({
+      name: `package script ${name}`,
+      command,
+    })),
+  ];
+}
+
+/**
+ * Top-level statements in a dev script that do work when it is imported.
+ *
+ * Declarations are allowed, initializers included — resolving a path at module
+ * scope is fine. A statement of its own at the top level is not: that is where
+ * `await main();` lives.
+ *
+ * @param script - Script path relative to the core package
+ * @returns `path:line` and source text for each offending statement
+ */
+function findTopLevelWork(script: string): string[] {
+  const source = ts.createSourceFile(
+    script,
+    readFileSync(resolve(CORE_DIR, script), "utf8"),
+    ts.ScriptTarget.Latest,
+    true,
+  );
+
+  return source.statements
+    .filter(
+      (statement) =>
+        !ts.isImportDeclaration(statement) &&
+        !ts.isExportDeclaration(statement) &&
+        !ts.isExportAssignment(statement) &&
+        !ts.isFunctionDeclaration(statement) &&
+        !ts.isClassDeclaration(statement) &&
+        !ts.isVariableStatement(statement) &&
+        !ts.isTypeAliasDeclaration(statement) &&
+        !ts.isInterfaceDeclaration(statement) &&
+        !ts.isEnumDeclaration(statement),
+    )
+    .map((statement) => {
+      const { line } = source.getLineAndCharacterOfPosition(
+        statement.getStart(),
+      );
+      return `${script}:${line + 1}: ${statement.getText()}`;
+    });
+}
+
+describe("dev scripts", () => {
+  it("runs every TypeScript dev script through the runner", () => {
+    const invocations = collectCommands().flatMap(({ name, command }) =>
+      [...command.matchAll(SCRIPT_INVOCATION)].map(([, runner, script]) => ({
+        name,
+        runner,
+        script,
+      })),
+    );
+
+    expect(invocations.map(({ script }) => script)).toEqual(
+      expect.arrayContaining([
+        "dev/scripts/bootstrap-node-dev.ts",
+        "dev/scripts/clean-node-dev.ts",
+        "dev/scripts/reset-node-dev.ts",
+        "dev/scripts/import-node-demo-site-export.ts",
+      ]),
+    );
+    expect(
+      invocations.filter(({ runner }) => !runner.endsWith(RUNNER)),
+    ).toEqual([]);
+  });
+
+  it("keeps each script's work behind its default export", () => {
+    expect(SCRIPTS.flatMap(findTopLevelWork)).toEqual([]);
+  });
+
+  it(
+    "loads every script and everything it imports",
+    { timeout: 150_000 },
+    () => {
+      // Loading evaluates each script. One that works at its top level would
+      // do that work here, so it is refused before anything runs.
+      expect(SCRIPTS.flatMap(findTopLevelWork)).toEqual([]);
+
+      // From the repo root, where `brand-export` runs: SWC once resolved its
+      // Lingui plugin against the working directory and failed from there.
+      const fromRoot = (path: string) => `packages/core/${path}`;
+      const result = spawnSync(
+        process.execPath,
+        [fromRoot(RUNNER), "--check", ...SCRIPTS.map(fromRoot)],
+        { cwd: REPO_ROOT, encoding: "utf8", timeout: 120_000 },
+      );
+
+      expect(result.error).toBeUndefined();
+      expect(result.status, result.stderr).toBe(0);
+      expect(result.stdout.trim().split("\n")).toEqual(
+        SCRIPTS.map((script) => `Loaded ${fromRoot(script)}`),
+      );
+    },
+  );
+
+  it(
+    "gives a script the NODE_ENV it was started with",
+    { timeout: 150_000 },
+    () => {
+      // Vite sets NODE_ENV=development when it starts, and a script's child
+      // processes inherit it: `db-node-load-demo`'s build produced Lit's
+      // development bundle that way.
+      const dir = mkdtempSync(join(tmpdir(), "jant-dev-script-"));
+      try {
+        const script = join(dir, "print-node-env.ts");
+        writeFileSync(
+          script,
+          "export default function main(): void {\n  console.log(String(process.env.NODE_ENV));\n}\n",
+        );
+        const env = { ...process.env };
+        delete env.NODE_ENV;
+
+        const result = spawnSync(process.execPath, [RUNNER, script], {
+          cwd: CORE_DIR,
+          encoding: "utf8",
+          env,
+          timeout: 120_000,
+        });
+
+        expect(result.status, result.stderr).toBe(0);
+        expect(result.stdout.trim()).toBe("undefined");
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    },
+  );
+});

package/src/__tests__/export-collection-order.test.ts

@@ -0,0 +1,276 @@
+/**
+ * A collection on an exported site lists its Threads in Jant's order.
+ *
+ * The theme's `collection-members` partial restates the order Jant's
+ * collection page and feed read from the database: pins in this collection
+ * first, then `newest`, `oldest`, or `rating_desc`, which read the whole
+ * Thread (its activity, its earliest published post, its highest rating),
+ * not only the root. This builds the export with the real Hugo binary and
+ * compares every page and feed with what Jant's services return.
+ *
+ * Skips when `hugo` is not on PATH, like the other Hugo build tests.
+ */
+
+import { rm } from "node:fs/promises";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { createTestDatabase, DEFAULT_TEST_SITE_ID } from "./helpers/db.js";
+import { makeSiteConfig } from "./helpers/export-fixtures.js";
+import {
+  buildHugoSite,
+  hugoAvailable,
+  readFeedSlugs,
+  readThreadSlugs,
+} from "./helpers/hugo-site.js";
+import { createCollectionService } from "../services/collection.js";
+import { createExportService } from "../services/export.js";
+import { createMediaService } from "../services/media.js";
+import { createPathService } from "../services/path.js";
+import { createPostService } from "../services/post.js";
+import {
+  resolveCollectionSortOrder,
+  supportsCollectionRatingSort,
+} from "../lib/collection-sort.js";
+import type { Database } from "../db/index.js";
+import type { CreatePost } from "../types/operations.js";
+import type { CollectionSortOrder } from "../types.js";
+
+const SITE_URL = "https://example.com";
+const at = (iso: string) => Math.floor(Date.parse(iso) / 1000);
+
+/** One collection per order, over the same Threads, plus the rating fallback. */
+const COLLECTIONS: { slug: string; sortOrder: CollectionSortOrder }[] = [
+  { slug: "by-newest", sortOrder: "newest" },
+  { slug: "by-oldest", sortOrder: "oldest" },
+  { slug: "by-rating", sortOrder: "rating_desc" },
+  // One rated Thread: too few to rank, so the page falls back to newest.
+  { slug: "few-rated", sortOrder: "rating_desc" },
+];
+
+describe.skipIf(!hugoAvailable)("collection order on an exported site", () => {
+  let siteDir: string;
+  const expected = new Map<string, string[]>();
+  const built = new Map<string, string[]>();
+  const expectedFeed = new Map<string, string[]>();
+  const builtFeed = new Map<string, string[]>();
+
+  beforeAll(async () => {
+    const { db: testDb } = createTestDatabase();
+    const db = testDb as unknown as Database;
+    const siteId = DEFAULT_TEST_SITE_ID;
+    const paths = createPathService(db, siteId);
+    const posts = createPostService(db, { slugIdLength: 5 }, siteId);
+    const collections = createCollectionService(db, siteId, paths);
+    const media = createMediaService(db, siteId);
+
+    const collectionIds = new Map<string, string>();
+    for (const { slug, sortOrder } of COLLECTIONS) {
+      const created = await collections.create({
+        slug,
+        title: slug,
+        sortOrder,
+      });
+      collectionIds.set(slug, created.id);
+    }
+    const inCollections = (slugs: string[], pinnedAt: number | null = null) =>
+      slugs.map((slug) => ({
+        collectionId: collectionIds.get(slug) as string,
+        pinnedAt,
+      }));
+    const ordered = ["by-newest", "by-oldest", "by-rating"];
+
+    const slugById = new Map<string, string>();
+    async function post(slug: string, data: Omit<CreatePost, "slug">) {
+      const created = await posts.create({
+        slug,
+        bodyMarkdown: `Body of ${slug}.`,
+        status: "published",
+        ...data,
+        createdAt: data.createdAt ?? data.publishedAt,
+      });
+      slugById.set(created.id, slug);
+      return created;
+    }
+    const reply = (
+      root: { id: string },
+      slug: string,
+      data: Omit<CreatePost, "slug" | "replyToId" | "format"> = {},
+    ) => post(slug, { format: "note", replyToId: root.id, ...data });
+
+    // A reply moves the Thread's activity to June.
+    const replied = await post("a-replied", {
+      format: "note",
+      publishedAt: at("2025-01-01T00:00:00Z"),
+      collectionEntries: inCollections([...ordered, "few-rated"]),
+    });
+    await reply(replied, "a-reply", {
+      publishedAt: at("2025-06-01T00:00:00Z"),
+    });
+
+    // Pinned in every ordered collection, rated on the root.
+    await post("b-pinned-rated", {
+      format: "note",
+      publishedAt: at("2025-02-01T00:00:00Z"),
+      rating: 3,
+      collectionEntries: [
+        ...inCollections(ordered, at("2025-07-01T00:00:00Z")),
+        ...inCollections(["few-rated"]),
+      ],
+    });
+
+    // Rated only on a reply: the Thread's rating is its highest.
+    const replyRated = await post("c-reply-rated", {
+      format: "note",
+      publishedAt: at("2025-03-01T00:00:00Z"),
+      collectionEntries: inCollections(ordered),
+    });
+    await reply(replyRated, "c-rated-reply", {
+      publishedAt: at("2025-03-02T00:00:00Z"),
+      rating: 5,
+    });
+
+    // Two Threads published in the same second: the ID decides.
+    await post("d-tied", {
+      format: "note",
+      publishedAt: at("2025-04-01T12:00:00Z"),
+      rating: 4,
+      collectionEntries: inCollections(ordered),
+    });
+    await post("e-tied", {
+      format: "note",
+      publishedAt: at("2025-04-01T12:00:00Z"),
+      collectionEntries: inCollections([...ordered, "few-rated"]),
+    });
+
+    // A reply dated before every other post: `oldest` reads the Thread's
+    // earliest published post, so this Thread comes first though its root
+    // is one of the later ones.
+    const early = await post("f-early-reply", {
+      format: "note",
+      publishedAt: at("2025-03-15T00:00:00Z"),
+      collectionEntries: inCollections(ordered),
+    });
+    await reply(early, "f-reply-before-root", {
+      publishedAt: at("2024-11-01T00:00:00Z"),
+    });
+
+    // Pinned more recently than b, with a quiet reply that doesn't move the
+    // Thread's activity.
+    const quiet = await post("g-pinned-quiet", {
+      format: "note",
+      publishedAt: at("2025-05-01T00:00:00Z"),
+      collectionEntries: inCollections(ordered, at("2025-08-01T00:00:00Z")),
+    });
+    await reply(quiet, "g-quiet-reply", {
+      publishedAt: at("2025-09-01T00:00:00Z"),
+      quietReply: true,
+    });
+
+    // Neither is on the page.
+    await post("h-private", {
+      format: "note",
+      visibility: "private",
+      publishedAt: at("2025-01-15T00:00:00Z"),
+      collectionEntries: inCollections(ordered),
+    });
+    await post("i-draft", {
+      format: "note",
+      status: "draft",
+      collectionEntries: inCollections(ordered),
+    });
+
+    const reader = { status: "published" as const, excludePrivate: true };
+    for (const { slug, sortOrder } of COLLECTIONS) {
+      const ids = [collectionIds.get(slug) as string];
+      // What the page shows, as the collection page route decides it.
+      const rated = await posts.countCollectionThreadRootsUpToForCollections(
+        ids,
+        { ...reader, hasRating: true },
+        2,
+      );
+      const pageOrder = resolveCollectionSortOrder(
+        undefined,
+        sortOrder,
+        supportsCollectionRatingSort(rated),
+      );
+      const rootIds = await posts.listCollectionThreadRootIdsForCollections(
+        ids,
+        { ...reader, sortOrder: pageOrder },
+      );
+      expected.set(
+        slug,
+        rootIds.map((id) => slugById.get(id) as string),
+      );
+      // What the feed carries, as the collection feed route asks for it.
+      const entries = await posts.listCollectionFeedEntriesForCollections(ids, {
+        ...reader,
+        ignoreCollectionPinnedSort: true,
+        limit: 50,
+      });
+      expectedFeed.set(
+        slug,
+        entries.map((entry) => slugById.get(entry.post.id) as string),
+      );
+    }
+
+    // A small page size, so the pages are read across pagination.
+    siteDir = await buildHugoSite(
+      await createExportService(
+        { posts, paths, collections, media },
+        makeSiteConfig({ siteUrl: SITE_URL, pageSize: 3 }),
+        { storage: null, bundleMedia: false },
+      ).generateHugoFiles(),
+    );
+    for (const { slug } of COLLECTIONS) {
+      built.set(slug, await readThreadSlugs(siteDir, slug));
+      builtFeed.set(slug, await readFeedSlugs(siteDir, slug, SITE_URL));
+    }
+  }, 60_000);
+
+  afterAll(async () => {
+    if (siteDir) await rm(siteDir, { recursive: true, force: true });
+  });
+
+  it.each(COLLECTIONS.map(({ slug }) => slug))(
+    "%s lists its Threads in Jant's order",
+    (slug) => {
+      expect(built.get(slug)).toEqual(expected.get(slug));
+    },
+  );
+
+  it.each(COLLECTIONS.map(({ slug }) => slug))(
+    "%s feed carries Jant's feed order",
+    (slug) => {
+      expect(builtFeed.get(slug)).toEqual(expectedFeed.get(slug));
+    },
+  );
+
+  // Equal lists prove nothing if the fixture can't tell the orders apart.
+  it("runs on a fixture where each rule changes the order", () => {
+    // Pins first, most recent first.
+    expect(expected.get("by-newest")?.slice(0, 2)).toEqual([
+      "g-pinned-quiet",
+      "b-pinned-rated",
+    ]);
+    // The reply dated before every other post puts its Thread first.
+    expect(expected.get("by-oldest")?.slice(2, 4)).toEqual([
+      "f-early-reply",
+      "a-replied",
+    ]);
+    // The rating on a reply ranks its Thread above a root rated lower.
+    expect(expected.get("by-rating")?.slice(2, 4)).toEqual([
+      "c-reply-rated",
+      "d-tied",
+    ]);
+    // One rated Thread: the page falls back to newest.
+    expect(expected.get("few-rated")).toEqual([
+      "a-replied",
+      "e-tied",
+      "b-pinned-rated",
+    ]);
+    // The feed ignores pins, and a quiet reply doesn't move its Thread up.
+    expect(expectedFeed.get("by-oldest")?.slice(0, 2)).toEqual([
+      "a-replied",
+      "g-pinned-quiet",
+    ]);
+  });
+});