@jant/core 0.6.15 → 0.6.16

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

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

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

@@ -116,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");
 
@@ -128,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();
@@ -222,3 +363,154 @@ describe("archive page ordering", () => {
     );
   });
 });
+
+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__/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,

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

@@ -51,11 +51,13 @@ describe("draft preview route", () => {
     expect(html).toContain("data-preview-status");
     expect(html).toContain("Draft preview");
     expect(html).toContain("This post isn’t published.");
+    expect(html).toContain("Edit draft");
+    expect(html).toContain(`/preview/${draft.slug}?edit=1`);
     expect(html).toContain('<meta name="robots" content="noindex, nofollow"');
     expect(html).not.toContain('rel="canonical"');
     expect(html).not.toContain("application/ld+json");
     expect(html).not.toContain("article:published_time");
-    expect(html).not.toContain('id="compose-dialog"');
+    expect(html).toContain('id="compose-dialog"');
   });
 
   it("renders every draft in a saved thread", async () => {

package/src/routes/pages/archive.tsx

@@ -21,6 +21,7 @@ import type {
 import type { AppVariables } from "../../types/app-context.js";
 import type {
   ArchiveFilters,
+  ArchiveSort,
   ArchiveView,
   ArchiveVisibility,
 } from "../../types/props.js";
@@ -66,6 +67,7 @@ interface ParsedArchiveParams {
   visibility?: ArchiveVisibility;
   visibilityAll: boolean;
   view?: ArchiveView;
+  sort: ArchiveSort;
   currentPage: number;
 }
 
@@ -144,6 +146,11 @@ function parseArchiveParams(
       ? viewParam
       : undefined;
 
+  // sort selects the time axis for ordering, month grouping, and the year
+  // filter alike — they must stay on the same column or the month headers
+  // stop agreeing with the order inside them.
+  const sort: ArchiveSort = q("sort") === "updated" ? "updated" : "published";
+
   // Page always comes from the actual request URL (pagination links use ?page=N)
   const pageParam = c.req.query("page");
   const currentPage = Math.max(1, parseInt(pageParam || "1", 10) || 1);
@@ -159,6 +166,7 @@ function parseArchiveParams(
     visibility,
     visibilityAll,
     view,
+    sort,
     currentPage,
   };
 }
@@ -187,12 +195,15 @@ function buildArchivePostFilters(
       : (params.visibility ?? undefined)
     : undefined;
 
-  let publishedAfter: number | undefined;
-  let publishedBefore: number | undefined;
-  if (params.validYear) {
-    publishedAfter = Date.UTC(params.validYear, 0, 1) / 1000;
-    publishedBefore = Date.UTC(params.validYear + 1, 0, 1) / 1000;
-  }
+  // The year filter follows the active axis, so every month bucket shown
+  // under `year=N` really belongs to that year.
+  const yearRange = params.validYear
+    ? {
+        after: Date.UTC(params.validYear, 0, 1) / 1000,
+        before: Date.UTC(params.validYear + 1, 0, 1) / 1000,
+      }
+    : undefined;
+  const sortsByActivity = params.sort === "updated";
 
   return {
     format: params.format,
@@ -206,20 +217,28 @@ function buildArchivePostFilters(
         ? { visibility: effectiveVisibility }
         : {}),
     collectionId,
-    publishedAfter,
-    publishedBefore,
+    ...(yearRange
+      ? sortsByActivity
+        ? { axisAfter: yearRange.after, axisBefore: yearRange.before }
+        : { publishedAfter: yearRange.after, publishedBefore: yearRange.before }
+      : {}),
     mediaKinds: params.mediaKinds,
     hasMedia: params.hasMedia,
     hasTitle: params.hasTitle,
     hasReplies: params.hasReplies,
-    sortBy: "published",
+    // "thread_updated", not "activity": the archive is the canonical all-posts
+    // view, and the quiet-reply switch only promises not to move a Thread on
+    // Latest. Here the honest answer is when the Thread last changed.
+    sortBy: sortsByActivity ? "thread_updated" : "published",
     ignorePinnedSort: true,
   };
 }
 
 /**
  * Build a query string from parsed archive params (for feed self-URL and
- * archive page feed link). Omits page-only params (view, page).
+ * archive page feed link). Omits view and page — those shape the rendered
+ * page, not the result set — but carries `sort`, so the feed button on an
+ * updated-sorted page hands back the matching feed.
  */
 function buildArchiveFeedQuery(params: ParsedArchiveParams): string {
   const qs = new URLSearchParams();
@@ -237,6 +256,7 @@ function buildArchiveFeedQuery(params: ParsedArchiveParams): string {
   if (params.hasReplies !== undefined) {
     qs.set("replies", params.hasReplies ? "any" : "none");
   }
+  if (params.sort === "updated") qs.set("sort", "updated");
   const str = qs.toString();
   return str ? `?${str}` : "";
 }
@@ -338,6 +358,7 @@ export async function renderArchivePage(
       services.posts.getDistinctYears({
         status: "published",
         excludeReplies: true,
+        sortBy: filters.sortBy,
       }),
       services.collections.list(),
     ]);
@@ -365,8 +386,12 @@ export async function renderArchivePage(
 
     const grouped = new Map<string, PostWithMedia[]>();
     for (const post of posts) {
-      const publishedAt = post.publishedAt ?? post.updatedAt;
-      const key = formatYearMonth(publishedAt, appConfig.timeZone);
+      // Bucket on the same axis the query sorted by, so groups stay ordered.
+      const groupedAt =
+        params.sort === "updated"
+          ? post.threadUpdatedAt
+          : (post.publishedAt ?? post.updatedAt);
+      const key = formatYearMonth(groupedAt, appConfig.timeZone);
       if (!grouped.has(key)) {
         grouped.set(key, []);
       }
@@ -438,6 +463,7 @@ export async function renderArchivePage(
     hasReplies: params.hasReplies,
     visibility: effectiveVisibility,
     view: params.view,
+    sort: params.sort === "updated" ? "updated" : undefined,
   };
 
   const feedQuery = buildArchiveFeedQuery(params);
@@ -448,7 +474,12 @@ export async function renderArchivePage(
   }));
 
   return renderPublicPage(c, {
-    title: buildPageTitle("Archive", navData.siteName),
+    // Distinguishes a bookmarked or shared ?sort=updated view in the tab bar.
+    title: buildPageTitle(
+      "Archive",
+      params.sort === "updated" ? "Recently updated" : undefined,
+      navData.siteName,
+    ),
     navData,
     content: (
       <ArchivePage
@@ -634,6 +665,17 @@ async function buildArchiveFeedData(
   // Feed mirrors the unauthenticated archive page: published + non-private,
   // including Hidden-from-Latest. /archive is the canonical "all posts" view,
   // so its feed must match.
+  //
+  // Ordered by publication by default, like the page it belongs to. Ordering
+  // by activity would make the feed's contents shift under a fixed
+  // `rssFeedLimit` — a new reply pulls an old Thread back into the window and
+  // pushes something else out — and it buys nothing in return, because readers
+  // key entries by id and will not re-surface one that merely moved.
+  // /latest/feed is the activity feed; this one is the chronological record.
+  //
+  // `?sort=updated` opts into the same axis the page uses, for a subscriber
+  // who wants that trade-off deliberately.
+  const sortsByActivity = params.sort === "updated";
   const filters: PostFilters = {
     format: params.format,
     status: "published",
@@ -645,14 +687,20 @@ async function buildArchiveFeedData(
     hasMedia: params.hasMedia,
     hasTitle: params.hasTitle,
     hasReplies: params.hasReplies,
+    sortBy: sortsByActivity ? "thread_updated" : "published",
     ignorePinnedSort: true,
+    // The year filter follows the active axis; the RSS delay always stays on
+    // publication, so a just-published post is never announced early.
     ...(params.validYear
-      ? {
-          publishedAfter: Date.UTC(params.validYear, 0, 1) / 1000,
-        }
+      ? sortsByActivity
+        ? {
+            axisAfter: Date.UTC(params.validYear, 0, 1) / 1000,
+            axisBefore: yearPublishedBefore,
+          }
+        : { publishedAfter: Date.UTC(params.validYear, 0, 1) / 1000 }
       : {}),
     publishedBefore:
-      yearPublishedBefore === undefined
+      yearPublishedBefore === undefined || sortsByActivity
         ? rssPublishedBefore
         : Math.min(yearPublishedBefore, rssPublishedBefore),
     limit: appConfig.rssFeedLimit,

package/src/routes/pages/page.tsx

@@ -260,6 +260,10 @@ async function renderPost(
     display.threadPostViews,
     c.var.appConfig.siteUrl,
   );
+  const draftEditHref = `${toPublicPath(
+    `/preview/${post.slug}`,
+    c.var.appConfig.sitePathPrefix,
+  )}?edit=1`;
 
   return renderPublicPage(c, {
     title: previewTitle
@@ -288,8 +292,7 @@ async function renderPost(
     navData,
     ...(options.isPreview
       ? {
-          pageChrome: <DraftPreviewBar />,
-          showComposeDialog: false,
+          pageChrome: <DraftPreviewBar editHref={draftEditHref} />,
           noindex: true,
         }
       : {}),

package/src/services/__tests__/collection.test.ts

@@ -309,7 +309,10 @@ describe("CollectionService", () => {
       ]);
     });
 
-    it("uses a later Root edit as the Thread's recent activity", async () => {
+    // The directory's "recent activity" uses the same definition as every
+    // other surface: the Thread gained a post. Editing one is not activity,
+    // or fixing a typo would reshuffle the whole collection directory.
+    it("does not treat a later Root edit as recent activity", async () => {
       vi.useFakeTimers();
       try {
         vi.setSystemTime(new Date("2024-01-01T00:00:00Z"));
@@ -326,6 +329,34 @@ describe("CollectionService", () => {
         vi.setSystemTime(new Date("2024-01-01T00:01:00Z"));
         await postService.update(root.id, { bodyMarkdown: "after" });
 
+        const directory = await collectionService.listDirectoryData();
+        expect(directory.collections[0]?.recentActivityAt).toBe(1704067200);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it("treats a new reply as recent activity", async () => {
+      vi.useFakeTimers();
+      try {
+        vi.setSystemTime(new Date("2024-01-01T00:00:00Z"));
+        const collection = await collectionService.create({
+          slug: "growing-thread",
+          title: "Growing Thread",
+        });
+        const root = await postService.create({
+          format: "note",
+          bodyMarkdown: "root",
+        });
+        await collectionService.addThread(collection.id, root.id);
+
+        vi.setSystemTime(new Date("2024-01-01T00:01:00Z"));
+        await postService.create({
+          format: "note",
+          bodyMarkdown: "reply",
+          replyToId: root.id,
+        });
+
         const directory = await collectionService.listDirectoryData();
         expect(directory.collections[0]?.recentActivityAt).toBe(1704067260);
       } finally {