@jant/core 0.6.14 → 0.6.15

package/src/routes/api/internal/__tests__/post-body-html.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+import { eq } from "drizzle-orm";
+import { createTestApp } from "../../../../__tests__/helpers/app.js";
+import { posts, sites } from "../../../../db/schema.js";
+import { POST_BODY_HTML_VERSION } from "../../../../lib/post-body-html.js";
+import { createPostService } from "../../../../services/post.js";
+import { internalPostBodyHtmlRoutes } from "../post-body-html.js";
+import { internalSitesRoutes } from "../sites.js";
+
+describe("Internal post body HTML rebuild routes", () => {
+  it("hides the current-site endpoint when no internal token is configured", async () => {
+    const { app } = createTestApp({ authenticated: false });
+    app.route("/api/internal/posts/body-html", internalPostBodyHtmlRoutes);
+
+    const response = await app.request(
+      "/api/internal/posts/body-html/rebuild",
+      { method: "POST" },
+    );
+
+    expect(response.status).toBe(404);
+  });
+
+  it("dry-runs and rebuilds the current site", async () => {
+    const { app, services, db } = createTestApp({
+      authenticated: false,
+      internalAdminToken: "internal-secret",
+    });
+    app.use("*", async (c, next) => {
+      c.set("appConfig", undefined as never);
+      await next();
+    });
+    app.route("/api/internal/posts/body-html", internalPostBodyHtmlRoutes);
+    const post = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Body[^1]\n\n[^1]: Definition",
+    });
+    await db
+      .update(posts)
+      .set({
+        bodyHtml: '<span class="sidenote">legacy</span>',
+        bodyHtmlVersion: 1,
+      })
+      .where(eq(posts.id, post.id));
+
+    const dryRun = await app.request("/api/internal/posts/body-html/rebuild", {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer internal-secret",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ dryRun: true, limit: 25 }),
+    });
+    expect(dryRun.status).toBe(200);
+    await expect(dryRun.json()).resolves.toMatchObject({
+      processed: 1,
+      wouldRebuild: 1,
+      rebuilt: 0,
+      targetVersion: POST_BODY_HTML_VERSION,
+    });
+
+    const rebuild = await app.request("/api/internal/posts/body-html/rebuild", {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer internal-secret",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ limit: 25 }),
+    });
+    expect(rebuild.status).toBe(200);
+    await expect(rebuild.json()).resolves.toMatchObject({
+      rebuilt: 1,
+      failed: 0,
+    });
+  });
+
+  it("rebuilds only the explicitly selected managed site", async () => {
+    const { app, services, db } = createTestApp({
+      authenticated: false,
+      internalAdminToken: "internal-secret",
+      siteResolutionMode: "host-based",
+    });
+    app.use("*", async (c, next) => {
+      c.set("appConfig", undefined as never);
+      await next();
+    });
+    app.route("/api/internal/sites", internalSitesRoutes);
+
+    const timestamp = Math.floor(Date.now() / 1000);
+    const secondSiteId = "sit_managed00000000000000000000";
+    await db.insert(sites).values({
+      id: secondSiteId,
+      key: "managed",
+      status: "active",
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    });
+    const defaultPost = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Default",
+    });
+    const managedService = createPostService(
+      db,
+      { slugIdLength: 5 },
+      secondSiteId,
+    );
+    const managedPost = await managedService.create({
+      format: "note",
+      bodyMarkdown: "Managed[^1]\n\n[^1]: Definition",
+    });
+    await db
+      .update(posts)
+      .set({ bodyHtmlVersion: 1 })
+      .where(eq(posts.id, defaultPost.id));
+    await db
+      .update(posts)
+      .set({ bodyHtmlVersion: 1 })
+      .where(eq(posts.id, managedPost.id));
+
+    const response = await app.request(
+      `/api/internal/sites/${secondSiteId}/posts/body-html/rebuild`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: "Bearer internal-secret",
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({}),
+      },
+    );
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      processed: 1,
+      rebuilt: 1,
+    });
+
+    const rows = await db
+      .select({ id: posts.id, version: posts.bodyHtmlVersion })
+      .from(posts);
+    expect(rows.find((row) => row.id === managedPost.id)?.version).toBe(
+      POST_BODY_HTML_VERSION,
+    );
+    expect(rows.find((row) => row.id === defaultPost.id)?.version).toBe(1);
+  });
+
+  it("rejects an unknown explicit site instead of reporting an empty success", async () => {
+    const { app } = createTestApp({
+      authenticated: false,
+      internalAdminToken: "internal-secret",
+      siteResolutionMode: "host-based",
+    });
+    app.route("/api/internal/sites", internalSitesRoutes);
+
+    const response = await app.request(
+      "/api/internal/sites/sit_missing/posts/body-html/rebuild",
+      {
+        method: "POST",
+        headers: { Authorization: "Bearer internal-secret" },
+      },
+    );
+
+    expect(response.status).toBe(404);
+  });
+});

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

@@ -120,7 +120,7 @@ describe("Internal site admin routes", () => {
         primaryHost: "locale-demo.example.com",
         siteName: "Locale Demo",
         siteLanguage: "en-US",
-        timeZone: "Asia/Shanghai",
+        timeZone: "Etc/GMT-8",
       }),
     });
 
@@ -139,10 +139,43 @@ describe("Internal site admin routes", () => {
       { key: "ONBOARDING_STATUS", value: "completed" },
       { key: "SITE_LANGUAGE", value: "en" },
       { key: "SITE_NAME", value: "Locale Demo" },
-      { key: "TIME_ZONE", value: "Asia/Shanghai" },
+      { key: "TIME_ZONE", value: "Etc/GMT-8" },
     ]);
   });
 
+  it("falls back to UTC instead of rejecting invalid browser timezone metadata", async () => {
+    const { app, sqlite } = createTestApp({
+      authenticated: false,
+      internalAdminToken: "internal-secret",
+      siteResolutionMode: "host-based",
+    });
+    app.route("/api/internal/sites", internalSitesRoutes);
+
+    const res = await app.request("/api/internal/sites", {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer internal-secret",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        key: "timezone-fallback",
+        primaryHost: "timezone-fallback.example.com",
+        siteName: "Timezone Fallback",
+        timeZone: "Unknown/Zone",
+      }),
+    });
+
+    expect(res.status).toBe(201);
+    const body = (await res.json()) as { siteId: string };
+    const timeZone = sqlite
+      .prepare(
+        'SELECT "value" FROM "site_setting" WHERE "site_id" = ? AND "key" = \'TIME_ZONE\'',
+      )
+      .get(body.siteId);
+
+    expect(timeZone).toBeUndefined();
+  });
+
   it("reports an unused key as available", async () => {
     const { app } = createTestApp({
       authenticated: false,

package/src/routes/api/internal/post-body-html.ts

@@ -0,0 +1,43 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import { requireInternalAdminApi } from "../../../middleware/auth.js";
+import { parseValidated } from "../../../lib/schemas.js";
+import { rebuildPostBodyHtmlWithRuntimeSettings } from "../../../services/post.js";
+import type { Bindings } from "../../../types.js";
+import type { AppVariables } from "../../../types/app-context.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const RebuildPostBodyHtmlSchema = z.object({
+  limit: z.number().int().positive().max(100).optional(),
+  cursor: z.string().trim().min(1).optional(),
+  dryRun: z.boolean().optional(),
+});
+
+export const internalPostBodyHtmlRoutes = new Hono<Env>();
+
+/**
+ * Rebuild the current site's materialized post body HTML projection.
+ *
+ * Callers follow `nextCursor` until `done`. The service owns rendering,
+ * compare-and-swap writes, and timestamp preservation; this route only
+ * validates the authenticated maintenance request.
+ */
+internalPostBodyHtmlRoutes.post(
+  "/rebuild",
+  requireInternalAdminApi(),
+  async (c) => {
+    const contentType = c.req.header("Content-Type") || "";
+    const rawBody = contentType.includes("application/json")
+      ? await c.req.json().catch(() => ({}))
+      : {};
+    const body = parseValidated(RebuildPostBodyHtmlSchema, rawBody);
+
+    const result = await rebuildPostBodyHtmlWithRuntimeSettings(
+      c.var.services,
+      c.env,
+      body,
+    );
+    return c.json(result);
+  },
+);

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

@@ -3,12 +3,14 @@ import { z } from "zod";
 import { requireInternalAdminApi } from "../../../middleware/auth.js";
 import { ConflictError } from "../../../lib/errors.js";
 import { parseValidated } from "../../../lib/schemas.js";
+import { rebuildPostBodyHtmlWithRuntimeSettings } from "../../../services/post.js";
 import {
   getConfiguredStorageDriver,
   getSiteResolutionMode,
 } from "../../../lib/env.js";
 import type { Bindings } from "../../../types.js";
 import type { AppVariables } from "../../../types/app-context.js";
+import { RebuildPostBodyHtmlSchema } from "./post-body-html.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
@@ -199,6 +201,28 @@ internalSitesRoutes.post(
   },
 );
 
+// Rebuild one managed site's materialized body HTML projection. Hosted fleet
+// orchestration stays in the control plane; core never silently widens a
+// content-facing operation to every tenant.
+internalSitesRoutes.post(
+  "/:siteId/posts/body-html/rebuild",
+  requireInternalAdminApi(),
+  async (c) => {
+    assertHostBasedMode(c.env);
+
+    const contentType = c.req.header("Content-Type") || "";
+    const rawBody = contentType.includes("application/json")
+      ? await c.req.json().catch(() => ({}))
+      : {};
+    const body = parseValidated(RebuildPostBodyHtmlSchema, rawBody);
+    const services = c.var.servicesForSite(c.req.param("siteId"));
+
+    return c.json(
+      await rebuildPostBodyHtmlWithRuntimeSettings(services, c.env, body),
+    );
+  },
+);
+
 internalSitesRoutes.get(
   "/:siteId/export",
   requireInternalAdminApi(),

package/src/routes/api/nav-items.ts

@@ -8,6 +8,7 @@ import { z } from "zod";
 import type { Bindings } from "../../types.js";
 import type { AppVariables } from "../../types/app-context.js";
 import { requireAuthApi } from "../../middleware/auth.js";
+import { requirePublicApiAccess } from "../../middleware/public-content-access.js";
 import {
   CreateNavItemSchema,
   NavItemIdSchema,
@@ -31,6 +32,11 @@ const MoveSchema = z.object({
   before: NavItemIdSchema.nullable().optional(),
 });
 
+const PageCandidatesQuerySchema = z.object({
+  q: z.string().trim().max(200).optional(),
+  limit: z.coerce.number().int().min(1).max(50).optional(),
+});
+
 async function withSiteHeaderHtml<T extends object>(
   c: Context<Env>,
   body: T,
@@ -48,11 +54,21 @@ async function withSiteHeaderHtml<T extends object>(
 }
 
 // List nav items
-navItemsApiRoutes.get("/", async (c) => {
+navItemsApiRoutes.get("/", requirePublicApiAccess(), async (c) => {
   const items = await c.var.services.navItems.list();
   return c.json({ navItems: items });
 });
 
+// Search published titled notes that can be added as pages (requires auth)
+navItemsApiRoutes.get("/pages", requireAuthApi(), async (c) => {
+  const query = parseValidated(PageCandidatesQuerySchema, c.req.query());
+  const pages = await c.var.services.navItems.listPageCandidates({
+    query: query.q,
+    limit: query.limit,
+  });
+  return c.json({ pages });
+});
+
 // Move nav item (requires auth) — must be before /:id
 navItemsApiRoutes.put("/:id/move", requireAuthApi(), async (c) => {
   const id = parseIdParam(c.req.param("id"), ID_PREFIX.navItem);
@@ -94,6 +110,13 @@ navItemsApiRoutes.post("/", requireAuthApi(), async (c) => {
       url: getCollectionPagePath(collection.slug),
       placement: body.placement,
     });
+  } else if (body.type === "page") {
+    item = await c.var.services.navItems.create({
+      type: "page",
+      postId: body.postId,
+      label: body.label,
+      placement: body.placement,
+    });
   } else {
     item = await c.var.services.navItems.create({
       type: "link",

package/src/routes/api/posts.ts

@@ -132,7 +132,7 @@ postsApiRoutes.get("/:id", requireAuthApi(), async (c) => {
   const id = parseIdParam(c.req.param("id"), ID_PREFIX.post);
 
   // Fetch post, media, and collections in parallel (all keyed by the same id)
-  const [post, mediaList, postCollections] = await Promise.all([
+  const [post, mediaList, threadCollections] = await Promise.all([
     c.var.services.posts.getById(id),
     c.var.services.media.getByPostId(id),
     c.var.services.collections.getCollectionsByPostId(id),
@@ -145,7 +145,7 @@ postsApiRoutes.get("/:id", requireAuthApi(), async (c) => {
     localPublicUrl,
     sitePathPrefix,
   } = c.var.appConfig;
-  const collectionIds = postCollections.map((col) => col.id);
+  const collectionIds = threadCollections.map((col) => col.id);
 
   return c.json(
     toApiPost(foundPost, {

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

@@ -88,6 +88,41 @@ describe("Public Archive API Routes", () => {
       expect(nextBody.posts[0].id).not.toBe(body.posts[0].id);
     });
 
+    it("paginates chronologically without promoting pinned posts", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const olderPinned = await services.posts.create({
+        format: "note",
+        title: "Older pinned post",
+        bodyMarkdown: "older",
+        pinned: true,
+        publishedAt: Date.UTC(2025, 0, 1) / 1000,
+      });
+      const newerUnpinned = await services.posts.create({
+        format: "note",
+        title: "Newer unpinned post",
+        bodyMarkdown: "newer",
+        publishedAt: Date.UTC(2026, 0, 1) / 1000,
+      });
+
+      const first = await app.request("/api/public/archive?limit=1");
+      expect(first.status).toBe(200);
+      const firstBody = await first.json();
+      expect(firstBody.posts.map((post: { id: string }) => post.id)).toEqual([
+        newerUnpinned.id,
+      ]);
+
+      const second = await app.request(
+        `/api/public/archive?limit=1&cursor=${firstBody.nextCursor}`,
+      );
+      expect(second.status).toBe(200);
+      const secondBody = await second.json();
+      expect(secondBody.posts.map((post: { id: string }) => post.id)).toEqual([
+        olderPinned.id,
+      ]);
+    });
+
     it("filters by year using publishedAt", async () => {
       const { app, services } = createTestApp({ authenticated: false });
       app.route("/api/public/archive", publicArchiveApiRoutes);

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

@@ -1,5 +1,7 @@
 import { describe, expect, it } from "vitest";
+import { eq } from "drizzle-orm";
 import { createTestApp } from "../../../../__tests__/helpers/app.js";
+import { posts } from "../../../../db/schema.js";
 import { publicPostsApiRoutes } from "../posts.js";
 
 describe("Public Posts API Routes", () => {
@@ -100,6 +102,32 @@ describe("Public Posts API Routes", () => {
       expect(body.posts[0]).not.toHaveProperty("bodyText");
     });
 
+    it("returns canonical v3 HTML when the stored projection is stale", async () => {
+      const { app, services, db } = createTestApp({ authenticated: false });
+      app.route("/api/public/posts", publicPostsApiRoutes);
+      const post = await services.posts.create({
+        format: "note",
+        title: "Footnote API",
+        bodyMarkdown: "API body[^1]\n\n[^1]: API definition",
+      });
+      await db
+        .update(posts)
+        .set({
+          bodyHtml: '<span class="sidenote">legacy</span>',
+          bodyHtmlVersion: 1,
+        })
+        .where(eq(posts.id, post.id));
+
+      const response = await app.request("/api/public/posts");
+      const body = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(body.posts[0].bodyHtml).toContain('role="doc-noteref"');
+      expect(body.posts[0].bodyHtml).toMatch(/id="fn-[a-z0-9]{13}-1"/);
+      expect(body.posts[0].bodyHtml).not.toContain(post.id);
+      expect(body.posts[0].bodyHtml).not.toContain("legacy");
+    });
+
     it("filters posts by a single collection slug", async () => {
       const { app, services } = createTestApp({ authenticated: false });
       app.route("/api/public/posts", publicPostsApiRoutes);
@@ -194,12 +222,20 @@ describe("Public Posts API Routes", () => {
         title: "Older",
         bodyMarkdown: "first",
         collectionIds: [collection.id],
+        publishedAt: 1000,
       });
       const newer = await services.posts.create({
         format: "note",
         title: "Newer",
         bodyMarkdown: "second",
         collectionIds: [collection.id],
+        publishedAt: 2000,
+      });
+      await services.posts.create({
+        format: "note",
+        bodyMarkdown: "Later reply to the older Thread",
+        replyToId: older.id,
+        publishedAt: 3000,
       });
 
       const res = await app.request(
@@ -213,6 +249,145 @@ describe("Public Posts API Routes", () => {
       expect(body.posts[1].id).toBe(newer.id);
     });
 
+    it("sorts collection results by Thread activity from Child Posts", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/posts", publicPostsApiRoutes);
+
+      const collection = await services.collections.create({
+        slug: "active-threads",
+        title: "Active Threads",
+      });
+      const olderRoot = await services.posts.create({
+        format: "note",
+        title: "Older root",
+        bodyMarkdown: "older",
+        collectionIds: [collection.id],
+        publishedAt: 1000,
+      });
+      const newerRoot = await services.posts.create({
+        format: "note",
+        title: "Newer root",
+        bodyMarkdown: "newer",
+        collectionIds: [collection.id],
+        publishedAt: 2000,
+      });
+      await services.posts.create({
+        format: "note",
+        bodyMarkdown: "new activity",
+        replyToId: olderRoot.id,
+        publishedAt: 3000,
+      });
+
+      const res = await app.request(
+        "/api/public/posts?collection=active-threads&sort=newest",
+      );
+      expect(res.status).toBe(200);
+
+      const body = await res.json();
+      expect(body.posts.map((post: { id: string }) => post.id)).toEqual([
+        olderRoot.id,
+        newerRoot.id,
+      ]);
+    });
+
+    it("sorts and cursor-paginates collection Threads by Child ratings", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/posts", publicPostsApiRoutes);
+
+      const collection = await services.collections.create({
+        slug: "rated-threads",
+        title: "Rated Threads",
+        sortOrder: "rating_desc",
+      });
+      const createRatedThread = async (
+        title: string,
+        publishedAt: number,
+        rating: number,
+      ) => {
+        const root = await services.posts.create({
+          format: "note",
+          title,
+          bodyMarkdown: `${title} root`,
+          collectionIds: [collection.id],
+          publishedAt,
+        });
+        await services.posts.create({
+          format: "note",
+          bodyMarkdown: `${title} rated Child`,
+          replyToId: root.id,
+          publishedAt: publishedAt + 100,
+          rating,
+        });
+        return root;
+      };
+
+      const highest = await createRatedThread("Highest", 1000, 5);
+      const middle = await createRatedThread("Middle", 2000, 3);
+      const lowest = await createRatedThread("Lowest", 3000, 1);
+
+      const firstRes = await app.request(
+        "/api/public/posts?collection=rated-threads&limit=1",
+      );
+      expect(firstRes.status).toBe(200);
+      const first = await firstRes.json();
+      expect(first.posts[0].id).toBe(highest.id);
+      expect(first.nextCursor).toBe(highest.id);
+
+      const secondRes = await app.request(
+        `/api/public/posts?collection=rated-threads&limit=1&cursor=${first.nextCursor}`,
+      );
+      expect(secondRes.status).toBe(200);
+      const second = await secondRes.json();
+      expect(second.posts[0].id).toBe(middle.id);
+      expect(second.nextCursor).toBe(middle.id);
+
+      const thirdRes = await app.request(
+        `/api/public/posts?collection=rated-threads&limit=1&cursor=${second.nextCursor}`,
+      );
+      expect(thirdRes.status).toBe(200);
+      const third = await thirdRes.json();
+      expect(third.posts[0].id).toBe(lowest.id);
+    });
+
+    it("keeps root format and Latest visibility filters for Collections", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/posts", publicPostsApiRoutes);
+
+      const collection = await services.collections.create({
+        slug: "mixed",
+        title: "Mixed",
+      });
+      const note = await services.posts.create({
+        format: "note",
+        title: "Visible note",
+        bodyMarkdown: "note",
+        collectionIds: [collection.id],
+      });
+      await services.posts.create({
+        format: "link",
+        title: "Visible link",
+        url: "https://example.com",
+        collectionIds: [collection.id],
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Hidden note",
+        bodyMarkdown: "hidden",
+        visibility: "latest_hidden",
+        collectionIds: [collection.id],
+      });
+
+      const res = await app.request(
+        "/api/public/posts?collection=mixed&format=note",
+      );
+      expect(res.status).toBe(200);
+
+      const body = await res.json();
+      expect(body.posts.map((post: { id: string }) => post.id)).toEqual([
+        note.id,
+      ]);
+    });
+
     it("allows overriding collection sort order via sort parameter", async () => {
       const { app, services } = createTestApp({ authenticated: false });
       app.route("/api/public/posts", publicPostsApiRoutes);
@@ -282,6 +457,39 @@ describe("Public Posts API Routes", () => {
       expect(body).not.toHaveProperty("body");
     });
 
+    it("returns the shared Thread Collections for a child post", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/posts", publicPostsApiRoutes);
+
+      const collection = await services.collections.create({
+        slug: "shared",
+        title: "Shared",
+      });
+      const root = await services.posts.create({
+        format: "note",
+        bodyMarkdown: "root",
+        collectionIds: [collection.id],
+      });
+      const child = await services.posts.create({
+        format: "note",
+        bodyMarkdown: "child",
+        replyToId: root.id,
+      });
+
+      const res = await app.request(`/api/public/posts/${child.slug}`);
+      expect(res.status).toBe(200);
+      await expect(res.json()).resolves.toMatchObject({
+        id: child.id,
+        collections: [
+          {
+            id: collection.id,
+            slug: "shared",
+            title: "Shared",
+          },
+        ],
+      });
+    });
+
     it("returns markdown instead of rendered fields when content=markdown", async () => {
       const { app, services } = createTestApp({ authenticated: false });
       app.route("/api/public/posts", publicPostsApiRoutes);

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

@@ -5,11 +5,14 @@ import type { AppVariables } from "../../../types/app-context.js";
 import { MEDIA_KINDS } from "../../../types.js";
 import { FormatSchema, parseValidated } from "../../../lib/schemas.js";
 import { toPublicPost } from "./posts.js";
+import { requirePublicApiEnabled } from "../../../middleware/public-content-access.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
 export const publicArchiveApiRoutes = new Hono<Env>();
 
+publicArchiveApiRoutes.use("*", requirePublicApiEnabled());
+
 const MediaKindSchema = z.enum(MEDIA_KINDS);
 const MEDIA_KIND_LIST = MEDIA_KINDS.join(", ");
 const INVALID_MEDIA_MESSAGE =
@@ -108,6 +111,7 @@ publicArchiveApiRoutes.get("/", async (c) => {
     hasMedia: mediaPresence ?? hasMedia,
     hasTitle: title ?? hasTitle,
     hasReplies: replies,
+    ignorePinnedSort: true,
   });
 
   const postIds = posts.map((post) => post.id);