@jant/core 0.6.14 → 0.6.16

package/src/routes/pages/__tests__/archive-params.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { createTestApp } from "../../../__tests__/helpers/app.js";
 import { archiveRoutes } from "../archive.js";
 
@@ -21,13 +21,45 @@ async function fetchFeed(
   return res.text();
 }
 
-function setupApp() {
-  const { app, services } = createTestApp({ authenticated: false });
+function setupApp(rssPublishDelaySeconds = 0) {
+  const { app, services } = createTestApp({
+    authenticated: false,
+    rssPublishDelaySeconds,
+  });
   app.route("/archive", archiveRoutes);
   return { app, services };
 }
 
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
 describe("archive feed filter params", () => {
+  it("applies the RSS publication delay", async () => {
+    const currentTime = 2_000_000;
+    vi.spyOn(Date, "now").mockReturnValue(currentTime * 1000);
+    const { app, services } = setupApp(300);
+    await services.posts.create({
+      format: "note",
+      title: "Eligible Archive Post",
+      bodyMarkdown: "Old enough for RSS",
+      status: "published",
+      publishedAt: currentTime - 300,
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Recent Archive Post",
+      bodyMarkdown: "Still inside the edit window",
+      status: "published",
+      publishedAt: currentTime,
+    });
+
+    const xml = await fetchFeed(app, "");
+
+    expect(xml).toContain("Eligible Archive Post");
+    expect(xml).not.toContain("Recent Archive Post");
+  });
+
   it("filters by title with the new param and the legacy fallback", async () => {
     const { app, services } = setupApp();
     await services.posts.create({
@@ -84,10 +116,23 @@ describe("archive feed filter params", () => {
       format: "note",
       bodyMarkdown: "text only body",
     });
+    await services.media.create({
+      filename: "unattached.jpg",
+      originalName: "unattached.jpg",
+      mimeType: "image/jpeg",
+      size: 1024,
+      storageKey: "media/unattached.jpg",
+    });
 
     const fresh = await fetchFeed(app, "?media=none");
     expect(fresh).toContain("text only body");
 
+    const page = await app.request("/archive?media=none");
+    expect(page.status).toBe(200);
+    const pageHtml = await page.text();
+    expect(pageHtml).toContain('aria-label="1 thread"');
+    expect(pageHtml).toContain("text only body");
+
     const legacy = await fetchFeed(app, "?hasMedia=0");
     expect(legacy).toContain("text only body");
 
@@ -96,6 +141,134 @@ describe("archive feed filter params", () => {
   });
 });
 
+describe("archive feed ordering", () => {
+  // The feed belongs to the archive page, so it uses the page's default axis.
+  // Ordering by activity would let a reply to an old Thread reshuffle the
+  // feed window under a fixed rssFeedLimit, and readers key entries by id
+  // anyway — a moved entry is not a re-surfaced one. /latest/feed is where
+  // activity ordering lives.
+  it("orders by publication, not by recent replies", async () => {
+    const { app, services } = setupApp();
+    const oldThread = await services.posts.create({
+      format: "note",
+      title: "Old thread with a new reply",
+      bodyMarkdown: "root from 2019",
+      publishedAt: Date.UTC(2019, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "reply from 2026",
+      replyToId: oldThread.id,
+      publishedAt: Date.UTC(2026, 5, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Plain newer post",
+      bodyMarkdown: "root from 2025",
+      publishedAt: Date.UTC(2025, 0, 1) / 1000,
+    });
+
+    const xml = await fetchFeed(app, "");
+
+    expect(xml.indexOf("Plain newer post")).toBeLessThan(
+      xml.indexOf("Old thread with a new reply"),
+    );
+  });
+
+  it("honors an explicit sort=updated, quiet replies included", async () => {
+    const { app, services } = setupApp();
+    const oldThread = await services.posts.create({
+      format: "note",
+      title: "Old thread with a new reply",
+      bodyMarkdown: "root from 2019",
+      publishedAt: Date.UTC(2019, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "quiet addition",
+      replyToId: oldThread.id,
+      publishedAt: Date.UTC(2026, 5, 1) / 1000,
+      quietReply: true,
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Plain newer post",
+      bodyMarkdown: "root from 2025",
+      publishedAt: Date.UTC(2025, 0, 1) / 1000,
+    });
+
+    const updated = await fetchFeed(app, "?sort=updated");
+    expect(updated.indexOf("Old thread with a new reply")).toBeLessThan(
+      updated.indexOf("Plain newer post"),
+    );
+
+    // Same URL param, same axis as the page — the default stays chronological.
+    const chronological = await fetchFeed(app, "");
+    expect(chronological.indexOf("Plain newer post")).toBeLessThan(
+      chronological.indexOf("Old thread with a new reply"),
+    );
+  });
+
+  it("scopes a year filter to the axis the feed is sorted on", async () => {
+    const { app, services } = setupApp();
+    const oldThread = await services.posts.create({
+      format: "note",
+      title: "Extended in 2026",
+      bodyMarkdown: "root from 2019",
+      publishedAt: Date.UTC(2019, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "addition",
+      replyToId: oldThread.id,
+      publishedAt: Date.UTC(2026, 5, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Published in 2025",
+      bodyMarkdown: "root from 2025",
+      publishedAt: Date.UTC(2025, 0, 1) / 1000,
+    });
+
+    const byActivity = await fetchFeed(app, "?sort=updated&year=2026");
+    expect(byActivity).toContain("Extended in 2026");
+    expect(byActivity).not.toContain("Published in 2025");
+
+    const byPublication = await fetchFeed(app, "?year=2025");
+    expect(byPublication).toContain("Published in 2025");
+    expect(byPublication).not.toContain("Extended in 2026");
+  });
+
+  it("keeps the same order after an old thread gains a reply", async () => {
+    const { app, services } = setupApp();
+    const first = await services.posts.create({
+      format: "note",
+      title: "Alpha",
+      bodyMarkdown: "alpha root",
+      publishedAt: Date.UTC(2020, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Beta",
+      bodyMarkdown: "beta root",
+      publishedAt: Date.UTC(2021, 0, 1) / 1000,
+    });
+
+    const before = await fetchFeed(app, "");
+    const orderBefore = before.indexOf("Beta") < before.indexOf("Alpha");
+
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "late addition",
+      replyToId: first.id,
+      publishedAt: Date.UTC(2026, 0, 1) / 1000,
+    });
+
+    const after = await fetchFeed(app, "");
+    expect(after.indexOf("Beta") < after.indexOf("Alpha")).toBe(orderBefore);
+  });
+});
+
 describe("archive page legacy param redirect", () => {
   it("redirects legacy boolean params to their single-word spelling", async () => {
     const { app } = setupApp();
@@ -133,3 +306,211 @@ describe("archive page legacy param redirect", () => {
     expect(res.headers.get("location")).toBe("/archive?title=any");
   });
 });
+
+describe("archive page ordering", () => {
+  it("orders threads by their root publication time, not recent replies", async () => {
+    const { app, services } = setupApp();
+    const olderThread = await services.posts.create({
+      format: "note",
+      title: "Older active thread",
+      bodyMarkdown: "older root",
+      publishedAt: Date.UTC(2024, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "recent reply",
+      replyToId: olderThread.id,
+      publishedAt: Date.UTC(2026, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Newer root thread",
+      bodyMarkdown: "newer root",
+      publishedAt: Date.UTC(2025, 0, 1) / 1000,
+    });
+
+    const res = await app.request("/archive");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+
+    expect(html.indexOf("Newer root thread")).toBeLessThan(
+      html.indexOf("Older active thread"),
+    );
+  });
+
+  it("keeps newer posts ahead of older pinned posts", async () => {
+    const { app, services } = setupApp();
+    await services.posts.create({
+      format: "note",
+      title: "Older pinned post",
+      bodyMarkdown: "older",
+      pinned: true,
+      publishedAt: Date.UTC(2025, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Newer unpinned post",
+      bodyMarkdown: "newer",
+      publishedAt: Date.UTC(2026, 0, 1) / 1000,
+    });
+
+    const res = await app.request("/archive?view=list");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+
+    expect(html.indexOf("Newer unpinned post")).toBeLessThan(
+      html.indexOf("Older pinned post"),
+    );
+  });
+});
+
+describe("archive page sort=updated", () => {
+  /**
+   * An old thread that recently gained a reply, plus a younger standalone
+   * thread. The two axes disagree about their order, which is the whole point
+   * of the toggle.
+   */
+  async function seedDivergingThreads(services: {
+    posts: {
+      create: (data: Record<string, unknown>) => Promise<{ id: string }>;
+    };
+  }) {
+    const olderThread = await services.posts.create({
+      format: "note",
+      title: "Growing thread",
+      bodyMarkdown: "root from 2019",
+      publishedAt: Date.UTC(2019, 2, 5) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "reply from 2026",
+      replyToId: olderThread.id,
+      publishedAt: Date.UTC(2026, 7, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Untouched newer thread",
+      bodyMarkdown: "root from 2025",
+      publishedAt: Date.UTC(2025, 0, 1) / 1000,
+    });
+  }
+
+  it("puts recently extended threads first", async () => {
+    const { app, services } = setupApp();
+    await seedDivergingThreads(services);
+
+    const res = await app.request("/archive?sort=updated");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+
+    expect(html.indexOf("Growing thread")).toBeLessThan(
+      html.indexOf("Untouched newer thread"),
+    );
+  });
+
+  it("buckets months on the same axis it sorts by", async () => {
+    const { app, services } = setupApp();
+    await seedDivergingThreads(services);
+
+    const byPublished = await (await app.request("/archive")).text();
+    expect(byPublished).toContain("March 2019");
+    expect(byPublished).not.toContain("August 2026");
+
+    const byActivity = await (
+      await app.request("/archive?sort=updated")
+    ).text();
+    expect(byActivity).toContain("August 2026");
+    expect(byActivity).not.toContain("March 2019");
+  });
+
+  it("scopes the year filter to the active axis", async () => {
+    const { app, services } = setupApp();
+    await seedDivergingThreads(services);
+
+    const activityYear = await (
+      await app.request("/archive?sort=updated&year=2026")
+    ).text();
+    expect(activityYear).toContain("Growing thread");
+    expect(activityYear).not.toContain("Untouched newer thread");
+
+    const publishedYear = await (
+      await app.request("/archive?year=2026")
+    ).text();
+    expect(publishedYear).not.toContain("Growing thread");
+  });
+
+  it("keeps the default axis unchanged without the param", async () => {
+    const { app, services } = setupApp();
+    await seedDivergingThreads(services);
+
+    const html = await (await app.request("/archive")).text();
+    expect(html.indexOf("Untouched newer thread")).toBeLessThan(
+      html.indexOf("Growing thread"),
+    );
+  });
+
+  it("distinguishes the updated view in the document title", async () => {
+    const { app, services } = setupApp();
+    await seedDivergingThreads(services);
+
+    const byPublished = await (await app.request("/archive")).text();
+    expect(byPublished).toContain("<title>Archive - ");
+    expect(byPublished).not.toContain("Recently updated");
+
+    const byActivity = await (
+      await app.request("/archive?sort=updated")
+    ).text();
+    expect(byActivity).toContain("<title>Archive - Recently updated - ");
+  });
+
+  it("ignores an unknown sort value", async () => {
+    const { app, services } = setupApp();
+    await seedDivergingThreads(services);
+
+    const html = await (await app.request("/archive?sort=nonsense")).text();
+    expect(html.indexOf("Untouched newer thread")).toBeLessThan(
+      html.indexOf("Growing thread"),
+    );
+  });
+
+  // The quiet-reply switch promises "won't move the thread to the top of
+  // latest". The archive is not Latest — it is the canonical all-posts view,
+  // and it already shows Hidden-from-Latest content. So its updated sort
+  // reports when the Thread actually changed.
+  it("surfaces quietly extended threads even though Latest does not", async () => {
+    const { app, services } = setupApp();
+    const quietThread = await services.posts.create({
+      format: "note",
+      title: "Quietly extended thread",
+      bodyMarkdown: "root from 2019",
+      publishedAt: Date.UTC(2019, 2, 5) / 1000,
+    });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "quiet addendum",
+      replyToId: quietThread.id,
+      publishedAt: Date.UTC(2026, 7, 1) / 1000,
+      quietReply: true,
+    });
+    await services.posts.create({
+      format: "note",
+      title: "Untouched newer thread",
+      bodyMarkdown: "root from 2025",
+      publishedAt: Date.UTC(2025, 0, 1) / 1000,
+    });
+
+    const html = await (await app.request("/archive?sort=updated")).text();
+    expect(html.indexOf("Quietly extended thread")).toBeLessThan(
+      html.indexOf("Untouched newer thread"),
+    );
+    expect(html).toContain("August 2026");
+
+    // Latest still honors the quiet flag.
+    const roots = await services.posts.list({
+      status: "published",
+      excludeReplies: true,
+      excludeLatestHidden: true,
+    });
+    expect(roots[0]?.title).toBe("Untouched newer thread");
+  });
+});

package/src/routes/pages/__tests__/collection-routing.test.ts

@@ -1,11 +1,11 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { createTestApp } from "../../../__tests__/helpers/app.js";
 import { collectionRoutes } from "../collection.js";
 import { collectionsPageRoutes } from "../collections.js";
 import { pageRoutes } from "../page.js";
 
-function createCollectionRoutingTestApp() {
-  const testApp = createTestApp();
+function createCollectionRoutingTestApp(rssPublishDelaySeconds = 0) {
+  const testApp = createTestApp({ rssPublishDelaySeconds });
   const { app } = testApp;
 
   app.use("*", async (c, next) => {
@@ -21,6 +21,10 @@ function createCollectionRoutingTestApp() {
   return testApp;
 }
 
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
 async function createCollectionWithPost(
   services: ReturnType<typeof createTestApp>["services"],
   {
@@ -42,7 +46,7 @@ async function createCollectionWithPost(
     bodyMarkdown: bodyMarkdown ?? postTitle,
     status: "published",
   });
-  await services.collections.addPost(collection.id, post.id);
+  await services.collections.addThread(collection.id, post.id);
   return { collection, post };
 }
 
@@ -50,11 +54,17 @@ describe("Collection Routing", () => {
   it("renders a single collection at its root path", async () => {
     const { app, services } = createCollectionRoutingTestApp();
 
-    await createCollectionWithPost(services, {
+    const { post } = await createCollectionWithPost(services, {
       slug: "reading",
       title: "Reading",
       postTitle: "Book log",
     });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Thread follow-up",
+      status: "published",
+      replyToId: post.id,
+    });
 
     const res = await app.request("/reading");
 
@@ -64,6 +74,23 @@ describe("Collection Routing", () => {
     const html = await res.text();
     expect(html).toContain("Reading");
     expect(html).toContain("Book log");
+    expect(html).toContain("Thread follow-up");
+  });
+
+  it("hides the collection feed button when feeds are disabled", async () => {
+    const { app, services } = createCollectionRoutingTestApp();
+    await services.settings.set("RSS_FEEDS_ENABLED", "false");
+    await createCollectionWithPost(services, {
+      slug: "reading",
+      title: "Reading",
+      postTitle: "Book log",
+    });
+
+    const response = await app.request("/reading");
+    const html = await response.text();
+
+    expect(response.status).toBe(200);
+    expect(html).not.toContain('class="feed-link"');
   });
 
   it("redirects namespaced single-collection paths to the root canonical URL", async () => {
@@ -139,6 +166,37 @@ describe("Collection Routing", () => {
     expect(xml).toContain("Film log");
   });
 
+  it("applies the RSS publication delay to Collection feeds", async () => {
+    const currentTime = 2_000_000;
+    vi.spyOn(Date, "now").mockReturnValue(currentTime * 1000);
+    const { app, services } = createCollectionRoutingTestApp(300);
+    const collection = await services.collections.create({
+      slug: "reading",
+      title: "Reading",
+    });
+    const eligible = await services.posts.create({
+      format: "note",
+      title: "Eligible Book Log",
+      bodyMarkdown: "Old enough for RSS",
+      status: "published",
+      publishedAt: currentTime - 300,
+    });
+    const recent = await services.posts.create({
+      format: "note",
+      title: "Recent Book Log",
+      bodyMarkdown: "Still inside the edit window",
+      status: "published",
+      publishedAt: currentTime,
+    });
+    await services.collections.addThread(collection.id, eligible.id);
+    await services.collections.addThread(collection.id, recent.id);
+
+    const xml = await (await app.request("/reading/feed")).text();
+
+    expect(xml).toContain("Eligible Book Log");
+    expect(xml).not.toContain("Recent Book Log");
+  });
+
   it("redirects canonical collection pages and feeds to collection aliases", async () => {
     const { app, services } = createCollectionRoutingTestApp();
 

package/src/routes/pages/__tests__/collections.test.ts

@@ -30,7 +30,7 @@ describe("Collections Listing Page - Data Logic", () => {
     );
   });
 
-  it("returns collections with post counts and recent activity", async () => {
+  it("returns collections with Thread counts and recent activity", async () => {
     const recipes = await collectionService.create({
       slug: "recipes",
       title: "Recipes",
@@ -40,7 +40,7 @@ describe("Collections Listing Page - Data Logic", () => {
       title: "Travel",
     });
 
-    // Add posts to recipes collection via junction table
+    // Add Threads to the recipes Collection.
     const p1 = await postService.create({
       format: "note",
       bodyMarkdown: "Recipe 1",
@@ -49,8 +49,8 @@ describe("Collections Listing Page - Data Logic", () => {
       format: "note",
       bodyMarkdown: "Recipe 2",
     });
-    await collectionService.addPost(recipes.id, p1.id);
-    await collectionService.addPost(recipes.id, p2.id);
+    await collectionService.addThread(recipes.id, p1.id);
+    await collectionService.addThread(recipes.id, p2.id);
 
     const directory = await collectionService.listDirectoryData();
 
@@ -59,9 +59,9 @@ describe("Collections Listing Page - Data Logic", () => {
       (c) => c.slug === "recipes",
     );
     const travelResult = directory.collections.find((c) => c.slug === "travel");
-    expect(recipesResult?.postCount).toBe(2);
+    expect(recipesResult?.threadCount).toBe(2);
     expect(recipesResult?.recentActivityAt).toBe(p2.lastActivityAt);
-    expect(travelResult?.postCount).toBe(0);
+    expect(travelResult?.threadCount).toBe(0);
     expect(travelResult?.recentActivityAt).toBeGreaterThan(0);
   });
 
@@ -86,13 +86,13 @@ describe("Collections Listing Page - Data Logic", () => {
       bodyMarkdown: "Will remain",
     });
 
-    await collectionService.addPost(col.id, post.id);
-    await collectionService.addPost(col.id, post2.id);
+    await collectionService.addThread(col.id, post.id);
+    await collectionService.addThread(col.id, post2.id);
 
     await postService.delete(post.id);
 
     const directory = await collectionService.listDirectoryData();
-    expect(directory.collections[0]?.postCount).toBe(1);
+    expect(directory.collections[0]?.threadCount).toBe(1);
     expect(directory.collections[0]?.recentActivityAt).toBe(
       post2.lastActivityAt,
     );

package/src/routes/pages/__tests__/featured.test.ts

@@ -39,12 +39,16 @@ describe("Featured Page - Data Logic", () => {
       bodyMarkdown: "Normal post",
       status: "published",
     });
-    await postService.create({
+    // Featuring an unpublished post is refused outright, so the only way a
+    // draft carries the flag is by being unpublished after the fact — the
+    // case this filter still has to catch.
+    const unpublished = await postService.create({
       format: "note",
       bodyMarkdown: "Draft featured",
       featured: true,
-      status: "draft",
+      status: "published",
     });
+    await postService.update(unpublished.id, { status: "draft" });
 
     const posts = await postService.list({
       featured: true,