@jant/core 0.6.6 → 0.6.8

package/src/routes/api/internal/sites.ts

@@ -3,7 +3,10 @@ import { z } from "zod";
 import { requireInternalAdminApi } from "../../../middleware/auth.js";
 import { ConflictError } from "../../../lib/errors.js";
 import { parseValidated } from "../../../lib/schemas.js";
-import { getSiteResolutionMode } from "../../../lib/env.js";
+import {
+  getConfiguredStorageDriver,
+  getSiteResolutionMode,
+} from "../../../lib/env.js";
 import type { Bindings } from "../../../types.js";
 import type { AppVariables } from "../../../types/app-context.js";
 
@@ -46,6 +49,10 @@ const SitePostCountsSchema = z.object({
   siteIds: z.array(z.string().trim().min(1)).max(200),
 });
 
+const CleanupSiteUploadsSchema = z.object({
+  limit: z.number().int().positive().max(500).optional(),
+});
+
 const ManagedSiteDomainSchema = z.object({
   host: z
     .string()
@@ -60,6 +67,20 @@ const ManagedSiteDomainSchema = z.object({
   makePrimary: z.boolean().optional(),
 });
 
+const RenameManagedSiteSchema = z.object({
+  key: ManagedSiteKeySchema,
+  primaryHost: z
+    .string()
+    .trim()
+    .toLowerCase()
+    .min(1)
+    .max(255)
+    .regex(
+      /^(?=.{1,255}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/,
+      "Primary host must be a valid hostname.",
+    ),
+});
+
 export const internalSitesRoutes = new Hono<Env>();
 
 function assertHostBasedMode(env: Bindings) {
@@ -142,6 +163,42 @@ internalSitesRoutes.get(
   },
 );
 
+// Clean up a single managed site's expired upload sessions and orphaned media
+// (uploaded during compose but never published). Invoked per-site by the
+// hosted control plane's scheduled maintenance. Self-hosted operators use the
+// host-scoped `POST /api/internal/uploads/cleanup` route / `jant uploads
+// cleanup` CLI instead.
+internalSitesRoutes.post(
+  "/:siteId/uploads/cleanup",
+  requireInternalAdminApi(),
+  async (c) => {
+    assertHostBasedMode(c.env);
+
+    const storage = c.var.storage;
+    if (!storage) {
+      return c.json(
+        { error: "File storage isn't set up. Check your server config." },
+        500,
+      );
+    }
+
+    const contentType = c.req.header("Content-Type") || "";
+    const rawBody = contentType.includes("application/json")
+      ? await c.req.json().catch(() => ({}))
+      : {};
+    const body = parseValidated(CleanupSiteUploadsSchema, rawBody);
+
+    const services = c.var.servicesForSite(c.req.param("siteId"));
+    const result = await services.uploads.cleanupExpired({
+      storage,
+      storageDriver: getConfiguredStorageDriver(c.env),
+      limit: body.limit,
+    });
+
+    return c.json(result);
+  },
+);
+
 internalSitesRoutes.get(
   "/:siteId/export",
   requireInternalAdminApi(),
@@ -198,6 +255,25 @@ internalSitesRoutes.post(
   },
 );
 
+internalSitesRoutes.post(
+  "/:siteId/rename",
+  requireInternalAdminApi(),
+  async (c) => {
+    assertHostBasedMode(c.env);
+    const body = parseValidated(RenameManagedSiteSchema, await c.req.json());
+    const result = await c.var.services.siteAdmin.renameManagedSite(
+      c.req.param("siteId"),
+      body,
+    );
+
+    return c.json({
+      primaryHost: result.domain.host,
+      siteId: result.site.id,
+      status: result.site.status,
+    });
+  },
+);
+
 internalSitesRoutes.get(
   "/:siteId/domains",
   requireInternalAdminApi(),

package/src/routes/api/public/__tests__/archive.test.ts

@@ -143,6 +143,72 @@ describe("Public Archive API Routes", () => {
       expect(noMediaBody.posts).toHaveLength(2);
     });
 
+    it("filters by title and media presence words", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const titled = await services.posts.create({
+        format: "note",
+        title: "Has title",
+        bodyMarkdown: "body",
+      });
+      const untitled = await services.posts.create({
+        format: "note",
+        bodyMarkdown: "body without title",
+      });
+
+      const withTitle = await app.request("/api/public/archive?title=any");
+      const withTitleBody = await withTitle.json();
+      expect(withTitleBody.posts.map((p: { id: string }) => p.id)).toEqual([
+        titled.id,
+      ]);
+
+      const noTitle = await app.request("/api/public/archive?title=none");
+      const noTitleBody = await noTitle.json();
+      expect(noTitleBody.posts.map((p: { id: string }) => p.id)).toEqual([
+        untitled.id,
+      ]);
+
+      const noMedia = await app.request("/api/public/archive?media=none");
+      const noMediaBody = await noMedia.json();
+      expect(noMediaBody.posts).toHaveLength(2);
+
+      const anyMedia = await app.request("/api/public/archive?media=any");
+      const anyMediaBody = await anyMedia.json();
+      expect(anyMediaBody.posts).toHaveLength(0);
+    });
+
+    it("filters threads and single posts via replies", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const threadRoot = await services.posts.create({
+        format: "note",
+        bodyMarkdown: "thread root",
+      });
+      await services.posts.create({
+        format: "note",
+        bodyMarkdown: "reply",
+        replyToId: threadRoot.id,
+      });
+      const standalone = await services.posts.create({
+        format: "note",
+        bodyMarkdown: "standalone",
+      });
+
+      const threads = await app.request("/api/public/archive?replies=any");
+      const threadsBody = await threads.json();
+      expect(threadsBody.posts.map((p: { id: string }) => p.id)).toEqual([
+        threadRoot.id,
+      ]);
+
+      const singles = await app.request("/api/public/archive?replies=none");
+      const singlesBody = await singles.json();
+      expect(singlesBody.posts.map((p: { id: string }) => p.id)).toEqual([
+        standalone.id,
+      ]);
+    });
+
     it("filters by media kind", async () => {
       const { app, services } = createTestApp({ authenticated: false });
       app.route("/api/public/archive", publicArchiveApiRoutes);

package/src/routes/api/public/archive.ts

@@ -12,20 +12,26 @@ export const publicArchiveApiRoutes = new Hono<Env>();
 
 const MediaKindSchema = z.enum(MEDIA_KINDS);
 const MEDIA_KIND_LIST = MEDIA_KINDS.join(", ");
-const INVALID_MEDIA_KIND_MESSAGE =
-  "Invalid media kind. Allowed: " + MEDIA_KIND_LIST;
+const INVALID_MEDIA_MESSAGE =
+  "Invalid media value. Allowed: any, none, or kinds: " + MEDIA_KIND_LIST;
 
 const BoolFlagSchema = z.enum(["0", "1"]).transform((value) => value === "1");
+const PresenceSchema = z
+  .enum(["any", "none"])
+  .transform((value) => value === "any");
 
 const ListPublicArchiveQuerySchema = z.object({
   format: FormatSchema.optional(),
   collection: z.string().optional(),
   year: z.coerce.number().int().min(1971).optional(),
+  // Kinds list (image,video,...) or presence words: any = posts with any
+  // attachment, none = posts without attachments.
   media: z
     .string()
     .optional()
     .transform((value, ctx) => {
       if (!value) return undefined;
+      if (value === "any" || value === "none") return value;
       const parts = value
         .split(",")
         .map((part) => part.trim())
@@ -35,12 +41,15 @@ const ListPublicArchiveQuerySchema = z.object({
       if (!result.success) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
-          message: INVALID_MEDIA_KIND_MESSAGE,
+          message: INVALID_MEDIA_MESSAGE,
         });
         return z.NEVER;
       }
       return result.data;
     }),
+  title: PresenceSchema.optional(),
+  replies: PresenceSchema.optional(),
+  // Deprecated: use media=any|none and title=any|none instead.
   hasMedia: BoolFlagSchema.optional(),
   hasTitle: BoolFlagSchema.optional(),
   cursor: z.string().optional(),
@@ -54,6 +63,8 @@ publicArchiveApiRoutes.get("/", async (c) => {
     collection,
     year,
     media,
+    title,
+    replies,
     hasMedia,
     hasTitle,
     cursor,
@@ -61,6 +72,10 @@ publicArchiveApiRoutes.get("/", async (c) => {
     content,
   } = parseValidated(ListPublicArchiveQuerySchema, c.req.query());
 
+  const mediaKinds = Array.isArray(media) ? media : undefined;
+  const mediaPresence =
+    media === "any" ? true : media === "none" ? false : undefined;
+
   let collectionIds: string[] | undefined;
   if (collection) {
     // Accept both "tech,art" and "tech+art", matching the page URL convention.
@@ -89,9 +104,10 @@ publicArchiveApiRoutes.get("/", async (c) => {
     excludeReplies: true,
     publishedAfter,
     publishedBefore,
-    mediaKinds: media,
-    hasMedia,
-    hasTitle,
+    mediaKinds,
+    hasMedia: mediaPresence ?? hasMedia,
+    hasTitle: title ?? hasTitle,
+    hasReplies: replies,
   });
 
   const postIds = posts.map((post) => post.id);

package/src/routes/api/telegram.ts

@@ -66,7 +66,8 @@ function uploadConfigFromEnv(env: Bindings): {
   maxFileSizeMB: number;
 } {
   const maxFileSizeMB =
-    parseInt(getEnvString(env, "UPLOAD_MAX_FILE_SIZE_MB") ?? "500", 10) || 500;
+    parseInt(getEnvString(env, "UPLOAD_MAX_FILE_SIZE_MB") ?? "1024", 10) ||
+    1024;
   return {
     storageDriver: getConfiguredStorageDriver(env),
     maxFileSizeMB,

package/src/routes/dash/custom-urls.tsx

@@ -507,7 +507,7 @@ function NewCustomUrlContent({
             type="text"
             data-bind="archiveQuery"
             class="input"
-            placeholder="format=note&hasTitle=0&visibility=public&view=list"
+            placeholder="format=note&title=none&visibility=public&view=list"
           />
           <p class="text-xs text-muted-foreground mt-1">
             {i18n._(

package/src/routes/dash/settings.tsx

@@ -57,6 +57,7 @@ import {
   getHostedControlPlaneAccountUrl,
   getHostedControlPlaneProviderLabel,
   getHostedControlPlaneSiteDeleteUrl,
+  getHostedControlPlaneSiteSettingsUrl,
 } from "../../lib/hosted-signin.js";
 import { syncHostedControlPlaneSiteAvatar } from "../../lib/hosted-control-plane-sync.js";
 import {
@@ -265,6 +266,11 @@ function demoRestrictionResponse(c: Context<Env>, message: string): Response {
 
 settingsRoutes.get("/", async (c) => {
   const navData = await getNavigationData(c);
+  const hostedControlPlaneSiteSettingsUrl =
+    getHostedControlPlaneSiteSettingsUrl(c.env, c.var.currentSite.id);
+  const hostedControlPlaneProviderLabel = getHostedControlPlaneProviderLabel(
+    c.env,
+  );
 
   return renderPublicPage(c, {
     title: buildPageTitle("Settings", navData.siteName),
@@ -274,6 +280,8 @@ settingsRoutes.get("/", async (c) => {
         <SettingsRootContent
           sitePathPrefix={c.var.appConfig.sitePathPrefix}
           demoMode={c.var.appConfig.demoMode}
+          hostedControlPlaneSiteSettingsUrl={hostedControlPlaneSiteSettingsUrl}
+          hostedControlPlaneProviderLabel={hostedControlPlaneProviderLabel}
         />
       </div>
     ),
@@ -990,10 +998,6 @@ settingsRoutes.get("/account", async (c) => {
   const hostedControlPlaneProviderLabel = getHostedControlPlaneProviderLabel(
     c.env,
   );
-  const hostedControlPlaneSiteDeleteUrl = getHostedControlPlaneSiteDeleteUrl(
-    c.env,
-    c.var.currentSite.id,
-  );
 
   return renderPublicPage(c, {
     title: buildPageTitle("Account", navData.siteName),
@@ -1010,7 +1014,6 @@ settingsRoutes.get("/account", async (c) => {
           demoMode={c.var.appConfig.demoMode}
           hostedControlPlaneAccountUrl={hostedControlPlaneAccountUrl}
           hostedControlPlaneProviderLabel={hostedControlPlaneProviderLabel}
-          hostedControlPlaneSiteDeleteUrl={hostedControlPlaneSiteDeleteUrl}
         />
       </>
     ),

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

@@ -0,0 +1,135 @@
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { archiveRoutes } from "../archive.js";
+
+/**
+ * Integration coverage for archive filter param handling.
+ *
+ * The page and the feed share parseArchiveParams. These tests pin down:
+ * - the new single-word params (title/replies/media=any|none),
+ * - the legacy hasTitle/hasReplies/hasMedia=1/0 fallback on the feed,
+ *   which keeps old subscriptions and stored custom archive URLs working,
+ * - the 308 canonical redirect on the page route for legacy spellings.
+ */
+
+async function fetchFeed(
+  app: { request: (path: string) => Promise<Response> },
+  query: string,
+): Promise<string> {
+  const res = await app.request(`/archive/feed${query}`);
+  expect(res.status).toBe(200);
+  return res.text();
+}
+
+function setupApp() {
+  const { app, services } = createTestApp({ authenticated: false });
+  app.route("/archive", archiveRoutes);
+  return { app, services };
+}
+
+describe("archive feed filter params", () => {
+  it("filters by title with the new param and the legacy fallback", async () => {
+    const { app, services } = setupApp();
+    await services.posts.create({
+      format: "note",
+      title: "Titled post",
+      bodyMarkdown: "body with heading",
+    });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "body without heading",
+    });
+
+    const fresh = await fetchFeed(app, "?title=none");
+    expect(fresh).toContain("body without heading");
+    expect(fresh).not.toContain("body with heading");
+
+    const legacy = await fetchFeed(app, "?hasTitle=0");
+    expect(legacy).toContain("body without heading");
+    expect(legacy).not.toContain("body with heading");
+  });
+
+  it("filters by replies with the new param and the legacy fallback", async () => {
+    const { app, services } = setupApp();
+    const root = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "thread root body",
+    });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "reply body",
+      replyToId: root.id,
+    });
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "standalone body",
+    });
+
+    const threads = await fetchFeed(app, "?replies=any");
+    expect(threads).toContain("thread root body");
+    expect(threads).not.toContain("standalone body");
+
+    const singles = await fetchFeed(app, "?replies=none");
+    expect(singles).toContain("standalone body");
+    expect(singles).not.toContain("thread root body");
+
+    const legacySingles = await fetchFeed(app, "?hasReplies=0");
+    expect(legacySingles).toContain("standalone body");
+    expect(legacySingles).not.toContain("thread root body");
+  });
+
+  it("treats media=none as the legacy hasMedia=0", async () => {
+    const { app, services } = setupApp();
+    await services.posts.create({
+      format: "note",
+      bodyMarkdown: "text only body",
+    });
+
+    const fresh = await fetchFeed(app, "?media=none");
+    expect(fresh).toContain("text only body");
+
+    const legacy = await fetchFeed(app, "?hasMedia=0");
+    expect(legacy).toContain("text only body");
+
+    const withMedia = await fetchFeed(app, "?media=any");
+    expect(withMedia).not.toContain("text only body");
+  });
+});
+
+describe("archive page legacy param redirect", () => {
+  it("redirects legacy boolean params to their single-word spelling", async () => {
+    const { app } = setupApp();
+
+    const res = await app.request("/archive?hasTitle=0");
+    expect(res.status).toBe(308);
+    expect(res.headers.get("location")).toBe("/archive?title=none");
+  });
+
+  it("preserves other params and rewrites only legacy ones", async () => {
+    const { app } = setupApp();
+
+    const res = await app.request(
+      "/archive?format=note&hasReplies=1&utm_source=newsletter",
+    );
+    expect(res.status).toBe(308);
+    expect(res.headers.get("location")).toBe(
+      "/archive?format=note&utm_source=newsletter&replies=any",
+    );
+  });
+
+  it("redirects visibility=latest_hidden to the hidden alias", async () => {
+    const { app } = setupApp();
+
+    const res = await app.request("/archive?visibility=latest_hidden");
+    expect(res.status).toBe(308);
+    expect(res.headers.get("location")).toBe("/archive?visibility=hidden");
+  });
+
+  it("drops a legacy param without overriding an explicit new one", async () => {
+    const { app } = setupApp();
+
+    const res = await app.request("/archive?title=any&hasTitle=0");
+    expect(res.status).toBe(308);
+    expect(res.headers.get("location")).toBe("/archive?title=any");
+  });
+});

package/src/routes/pages/archive.tsx

@@ -57,6 +57,7 @@ interface ParsedArchiveParams {
   mediaKinds?: MediaKind[];
   hasMedia?: boolean;
   hasTitle?: boolean;
+  hasReplies?: boolean;
   visibility?: ArchiveVisibility;
   visibilityAll: boolean;
   view?: ArchiveView;
@@ -87,25 +88,45 @@ function parseArchiveParams(
 
   const collectionSlug = q("collection") || undefined;
 
-  const mediaParam = q("media") || undefined;
-  const mediaKinds = mediaParam
-    ? (mediaParam
-        .split(",")
-        .filter((m): m is MediaKind =>
-          (MEDIA_KINDS as readonly string[]).includes(m),
-        ) as MediaKind[])
-    : undefined;
+  // Presence filters use single-word params with any/none values
+  // (media=any|none|<kinds>, title=any|none, replies=any|none). The legacy
+  // hasMedia/hasTitle/hasReplies=1/0 params are still accepted so old
+  // bookmarks, feed subscriptions, and stored custom archive URLs keep
+  // working; new URLs are always generated in the new style.
+  const parsePresence = (
+    param: string | undefined,
+    legacy: string | undefined,
+  ): boolean | undefined => {
+    if (param === "any") return true;
+    if (param === "none") return false;
+    if (legacy === "1") return true;
+    if (legacy === "0") return false;
+    return undefined;
+  };
 
-  const hasMediaParam = q("hasMedia");
-  const hasMedia =
-    hasMediaParam === "1" ? true : hasMediaParam === "0" ? false : undefined;
+  const mediaParam = q("media") || undefined;
+  const mediaIsPresence = mediaParam === "any" || mediaParam === "none";
+  const mediaKinds =
+    mediaParam && !mediaIsPresence
+      ? (mediaParam
+          .split(",")
+          .filter((m): m is MediaKind =>
+            (MEDIA_KINDS as readonly string[]).includes(m),
+          ) as MediaKind[])
+      : undefined;
+  const hasMedia = parsePresence(
+    mediaIsPresence ? mediaParam : undefined,
+    q("hasMedia"),
+  );
 
-  const hasTitleParam = q("hasTitle");
-  const hasTitle =
-    hasTitleParam === "1" ? true : hasTitleParam === "0" ? false : undefined;
+  const hasTitle = parsePresence(q("title"), q("hasTitle"));
+  const hasReplies = parsePresence(q("replies"), q("hasReplies"));
 
   const VALID_VISIBILITIES = ["public", "latest_hidden", "private", "featured"];
-  const visibilityParam = q("visibility");
+  const rawVisibilityParam = q("visibility");
+  // "hidden" is the URL spelling of the internal latest_hidden value
+  const visibilityParam =
+    rawVisibilityParam === "hidden" ? "latest_hidden" : rawVisibilityParam;
   const visibilityAll = visibilityParam === "all";
   const visibility =
     visibilityParam && VALID_VISIBILITIES.includes(visibilityParam)
@@ -129,6 +150,7 @@ function parseArchiveParams(
     mediaKinds: mediaKinds && mediaKinds.length > 0 ? mediaKinds : undefined,
     hasMedia,
     hasTitle,
+    hasReplies,
     visibility,
     visibilityAll,
     view,
@@ -184,6 +206,7 @@ function buildArchivePostFilters(
     mediaKinds: params.mediaKinds,
     hasMedia: params.hasMedia,
     hasTitle: params.hasTitle,
+    hasReplies: params.hasReplies,
   };
 }
 
@@ -198,12 +221,14 @@ function buildArchiveFeedQuery(params: ParsedArchiveParams): string {
   if (params.collectionSlug) qs.set("collection", params.collectionSlug);
   if (params.mediaKinds && params.mediaKinds.length > 0) {
     qs.set("media", params.mediaKinds.join(","));
-  }
-  if (params.hasMedia !== undefined) {
-    qs.set("hasMedia", params.hasMedia ? "1" : "0");
+  } else if (params.hasMedia !== undefined) {
+    qs.set("media", params.hasMedia ? "any" : "none");
   }
   if (params.hasTitle !== undefined) {
-    qs.set("hasTitle", params.hasTitle ? "1" : "0");
+    qs.set("title", params.hasTitle ? "any" : "none");
+  }
+  if (params.hasReplies !== undefined) {
+    qs.set("replies", params.hasReplies ? "any" : "none");
   }
   const str = qs.toString();
   return str ? `?${str}` : "";
@@ -211,6 +236,49 @@ function buildArchiveFeedQuery(params: ParsedArchiveParams): string {
 
 export const archiveRoutes = new Hono<Env>();
 
+/**
+ * Build a canonical redirect target when a request uses legacy archive
+ * param spellings (hasMedia/hasTitle/hasReplies=1/0, visibility=latest_hidden).
+ *
+ * Only legacy params are rewritten; everything else (including unknown
+ * params) is preserved. Returns null when the URL is already canonical.
+ * Applies to the /archive page only — feeds and the public API accept
+ * legacy spellings silently, and custom archive URLs (path_registry
+ * query overrides) never reach this path.
+ *
+ * @param c - Hono context
+ * @returns Canonical path + query to redirect to, or null
+ */
+function legacyArchiveParamsRedirect(c: Context<Env>): string | null {
+  const url = new URL(c.req.url);
+  const params = url.searchParams;
+  let changed = false;
+
+  const rewrites = [
+    ["hasMedia", "media"],
+    ["hasTitle", "title"],
+    ["hasReplies", "replies"],
+  ] as const;
+  for (const [legacy, name] of rewrites) {
+    const value = params.get(legacy);
+    if (value === null) continue;
+    if (!params.has(name) && (value === "1" || value === "0")) {
+      params.set(name, value === "1" ? "any" : "none");
+    }
+    params.delete(legacy);
+    changed = true;
+  }
+
+  if (params.get("visibility") === "latest_hidden") {
+    params.set("visibility", "hidden");
+    changed = true;
+  }
+
+  if (!changed) return null;
+  const qs = params.toString();
+  return `${url.pathname}${qs ? `?${qs}` : ""}`;
+}
+
 // =============================================================================
 // Archive page — shared rendering
 // =============================================================================
@@ -360,6 +428,7 @@ export async function renderArchivePage(
     mediaKinds: params.mediaKinds,
     hasMedia: params.hasMedia,
     hasTitle: params.hasTitle,
+    hasReplies: params.hasReplies,
     visibility: effectiveVisibility,
     view: params.view,
   };
@@ -397,7 +466,11 @@ export async function renderArchivePage(
 // Archive page route
 // =============================================================================
 
-archiveRoutes.get("/", (c) => renderArchivePage(c));
+archiveRoutes.get("/", (c) => {
+  const canonical = legacyArchiveParamsRedirect(c);
+  if (canonical) return c.redirect(canonical, 308);
+  return renderArchivePage(c);
+});
 
 // =============================================================================
 // Archive feed
@@ -492,6 +565,28 @@ function buildArchiveFeedTitle(
     );
   }
 
+  if (params.hasReplies === true) {
+    parts.push(
+      i18n._(
+        msg({
+          message: "threads",
+          comment:
+            "@context: Archive feed title segment for hasReplies=1 filter",
+        }),
+      ),
+    );
+  } else if (params.hasReplies === false) {
+    parts.push(
+      i18n._(
+        msg({
+          message: "single posts",
+          comment:
+            "@context: Archive feed title segment for hasReplies=0 filter",
+        }),
+      ),
+    );
+  }
+
   if (params.validYear) {
     parts.push(String(params.validYear));
   }
@@ -534,6 +629,7 @@ async function buildArchiveFeedData(
     mediaKinds: params.mediaKinds,
     hasMedia: params.hasMedia,
     hasTitle: params.hasTitle,
+    hasReplies: params.hasReplies,
     ...(params.validYear
       ? {
           publishedAfter: Date.UTC(params.validYear, 0, 1) / 1000,

package/src/routes/pages/collections.tsx

@@ -71,6 +71,7 @@ collectionsPageRoutes.get("/", async (c) => {
         items={directoryData.items}
         isAuthenticated={navData.isAuthenticated ?? false}
         sitePathPrefix={navData.sitePathPrefix}
+        siteOrigin={c.var.appConfig.siteOrigin}
       />
     ),
   });