@jant/core 0.3.48 → 0.3.50

package/dist/{app-DdnIoX7y.js → app-C7CtIQM-.js}

@@ -3418,7 +3418,7 @@ function normalizeThemeColorForMeta(color) {
 * internal paths (e.g. `/_assets/client-HASH.js`) embedded by the Worker build
 * from the Vite client manifest. Used only in production (IS_VITE_DEV=false).
 */ var IS_VITE_DEV = typeof __JANT_DEV__ !== "undefined" && __JANT_DEV__ === true;
-var CORE_VERSION = "0.3.48-5b409c34fc5f0c4a";
+var CORE_VERSION = "0.3.50-947a76e8ff575c8d";
 var CLIENT_JS_FILE = "/_assets/client-dSfWfMe9.js";
 var CLIENT_AUTH_JS_FILE = "/_assets/client-auth-Ce5WEAVS.js";
 var CLIENT_CSS_FILE = "/_assets/client-BoUn7xBo.css";
@@ -3739,7 +3739,7 @@ var IconSprite = () => {
 	const cjkSerifFont = appConfig?.cjkSerifFont ?? "off";
 	const cjkStylesheetPath = cjkSerifFont === "zh-Hans" ? IS_VITE_DEV ? assetPath("/src/style-cjk.css") : toPublicAssetPath(CLIENT_CJK_CSS_FILE, assetBasePath) : cjkSerifFont === "zh-Hant" ? IS_VITE_DEV ? assetPath("/src/style-cjk-tc.css") : toPublicAssetPath(CLIENT_CJK_TC_CSS_FILE, assetBasePath) : cjkSerifFont === "ja" ? IS_VITE_DEV ? assetPath("/src/style-cjk-jp.css") : toPublicAssetPath(CLIENT_CJK_JP_CSS_FILE, assetBasePath) : cjkSerifFont === "ko" ? IS_VITE_DEV ? assetPath("/src/style-cjk-kr.css") : toPublicAssetPath(CLIENT_CJK_KR_CSS_FILE, assetBasePath) : null;
 	const clientScriptPath = IS_VITE_DEV ? resolvedClientBundle === "full" ? assetPath("/src/client-auth.ts") : assetPath("/src/client.ts") : toPublicAssetPath(resolvedClientBundle === "full" ? CLIENT_AUTH_JS_FILE : CLIENT_JS_FILE, assetBasePath);
-	const faviconAssetVersion = resolvedFaviconVersion || "0.3.48-5b409c34fc5f0c4a";
+	const faviconAssetVersion = resolvedFaviconVersion || "0.3.50-947a76e8ff575c8d";
 	const resolvedFaviconHref = faviconHref ?? (faviconAssetVersion ? toPublicPath(`/favicon.ico?v=${faviconAssetVersion}`, sitePathPrefix) : toPublicPath("/favicon.ico", sitePathPrefix));
 	const resolvedAppleTouchHref = appleTouchHref ?? (faviconAssetVersion ? toPublicPath(`/apple-touch-icon.png?v=${faviconAssetVersion}`, sitePathPrefix) : toPublicPath("/apple-touch-icon.png", sitePathPrefix));
 	const socialImageHref = resolvedSocialImagePath && (isFullUrl(resolvedSocialImagePath) || resolvedSocialImagePath.startsWith("//") ? resolvedSocialImagePath : toAbsoluteSiteUrl(resolvedSocialImagePath, appConfig?.siteUrl || "", sitePathPrefix));
@@ -8811,7 +8811,7 @@ function getMediaPlaceholderDataUrl(blurhash, width, height) {
 	return blurhashToDataUrl(blurhash, decodeSize.width, decodeSize.height);
 }
 function getSingleVisualWidth(ratio) {
-	return `min(100%, calc(24rem * ${ratio}))`;
+	return `min(100%, calc(24rem * ${ratio}), var(--layout-content-width))`;
 }
 /**
 * Format-specific file icon. Each MIME type gets a visually distinct icon
@@ -25344,6 +25344,72 @@ publicPostsApiRoutes.get("/:slug", async (c) => {
 	return c.json(toPublicPost(post, mediaList, postCollections, c.var.appConfig, { content }));
 });
 //#endregion
+//#region src/routes/api/public/archive.ts
+var publicArchiveApiRoutes = new Hono();
+var MediaKindSchema = z.enum(MEDIA_KINDS);
+var INVALID_MEDIA_KIND_MESSAGE = "Invalid media kind. Allowed: " + MEDIA_KINDS.join(", ");
+var BoolFlagSchema = z.enum(["0", "1"]).transform((value) => value === "1");
+var ListPublicArchiveQuerySchema = z.object({
+	format: FormatSchema.optional(),
+	collection: z.string().optional(),
+	year: z.coerce.number().int().min(1971).optional(),
+	media: z.string().optional().transform((value, ctx) => {
+		if (!value) return void 0;
+		const parts = value.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+		if (parts.length === 0) return void 0;
+		const result = z.array(MediaKindSchema).safeParse(parts);
+		if (!result.success) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: INVALID_MEDIA_KIND_MESSAGE
+			});
+			return z.NEVER;
+		}
+		return result.data;
+	}),
+	hasMedia: BoolFlagSchema.optional(),
+	hasTitle: BoolFlagSchema.optional(),
+	cursor: z.string().optional(),
+	limit: z.coerce.number().int().min(1).max(100).optional().default(20),
+	content: z.enum(["markdown"]).optional()
+});
+publicArchiveApiRoutes.get("/", async (c) => {
+	const { format, collection, year, media, hasMedia, hasTitle, cursor, limit, content } = parseValidated(ListPublicArchiveQuerySchema, c.req.query());
+	let collectionIds;
+	if (collection) {
+		const slugExpression = collection.replace(/,/g, "+");
+		const selection = await c.var.services.collections.resolveSelection(slugExpression);
+		if (!selection || selection.collections.length === 0) return c.json({
+			posts: [],
+			nextCursor: null
+		});
+		collectionIds = selection.collections.map((col) => col.id);
+	}
+	const publishedAfter = year !== void 0 ? Date.UTC(year, 0, 1) / 1e3 : void 0;
+	const publishedBefore = year !== void 0 ? Date.UTC(year + 1, 0, 1) / 1e3 : void 0;
+	const posts = await c.var.services.posts.list({
+		format,
+		collectionIds,
+		status: "published",
+		cursor: cursor ?? void 0,
+		limit,
+		excludePrivate: true,
+		excludeLatestHidden: false,
+		excludeReplies: true,
+		publishedAfter,
+		publishedBefore,
+		mediaKinds: media,
+		hasMedia,
+		hasTitle
+	});
+	const postIds = posts.map((post) => post.id);
+	const [mediaMap, collectionsMap] = await Promise.all([c.var.services.media.getByPostIds(postIds), c.var.services.collections.getCollectionsByPostIds(postIds)]);
+	return c.json({
+		posts: posts.map((post) => toPublicPost(post, mediaMap.get(post.id) ?? [], collectionsMap.get(post.id) ?? [], c.var.appConfig, { content })),
+		nextCursor: posts.length === limit ? posts[posts.length - 1]?.id ?? null : null
+	});
+});
+//#endregion
 //#region src/routes/compose.tsx
 /**
 * Compose Route
@@ -31993,6 +32059,7 @@ async function servePublicStorage(c) {
 	app.use("*", withConfig());
 	app.use("*", i18nMiddleware());
 	app.route("/api/public/posts", publicPostsApiRoutes);
+	app.route("/api/public/archive", publicArchiveApiRoutes);
 	app.route("/api/posts", postsApiRoutes);
 	app.route("/api/nav-items", navItemsApiRoutes);
 	app.route("/api/collections", collectionsApiRoutes);

package/dist/{app-DU7dpJID.js → app-CIx9SSOi.js}

@@ -1,5 +1,5 @@
 import "./url-umUptr5z.js";
-import { t as createApp } from "./app-DdnIoX7y.js";
+import { t as createApp } from "./app-C7CtIQM-.js";
 import "./export-ZBlfKSKm.js";
 import "./env-CgaH9Mut.js";
 import "./github-sync-bL1hnx3Q.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 import { _ as url_exports } from "./url-umUptr5z.js";
-import { A as NAV_ITEM_TYPES, C as toPostView, D as MAX_MEDIA_ATTACHMENTS, E as FORMATS, M as STATUSES, N as TEXT_ATTACHMENT_CONTENT_FORMATS, O as MAX_PINNED_POSTS, S as toNavItemViews, T as toSearchResultView, _ as createMediaContext, b as toMediaView, f as defaultFeedRenderer, j as SORT_ORDERS, k as MEDIA_KINDS, t as createApp, v as toArchiveGroups, w as toPostViews, x as toNavItemView, y as toArchiveGroupsWithMedia } from "./app-DdnIoX7y.js";
+import { A as NAV_ITEM_TYPES, C as toPostView, D as MAX_MEDIA_ATTACHMENTS, E as FORMATS, M as STATUSES, N as TEXT_ATTACHMENT_CONTENT_FORMATS, O as MAX_PINNED_POSTS, S as toNavItemViews, T as toSearchResultView, _ as createMediaContext, b as toMediaView, f as defaultFeedRenderer, j as SORT_ORDERS, k as MEDIA_KINDS, t as createApp, v as toArchiveGroups, w as toPostViews, x as toNavItemView, y as toArchiveGroupsWithMedia } from "./app-C7CtIQM-.js";
 import { T as time_exports, a as markdown_exports } from "./export-ZBlfKSKm.js";
 import "./env-CgaH9Mut.js";
 import "./github-sync-bL1hnx3Q.js";

package/dist/node.js

@@ -1,5 +1,5 @@
 import "./url-umUptr5z.js";
-import { F as BUILTIN_COLOR_THEMES, I as getPublicAssetBasePath, L as isAssetPath, P as buildThemeStyle, a as resolveDatabaseDialect, c as resolveConfig, d as getFontThemeCssVariables, g as schema_exports, h as createNodeDatabase, i as createSiteService, l as BUILTIN_FONT_THEMES, m as sqliteSchemaBundle, n as createNodeCliRuntime, o as getHostBasedStartupConfigurationIssues, p as pgSchemaBundle, r as createNodeRequestRuntime, s as createStorageDriver, t as createApp, u as getCjkSerifCssVariables } from "./app-DdnIoX7y.js";
+import { F as BUILTIN_COLOR_THEMES, I as getPublicAssetBasePath, L as isAssetPath, P as buildThemeStyle, a as resolveDatabaseDialect, c as resolveConfig, d as getFontThemeCssVariables, g as schema_exports, h as createNodeDatabase, i as createSiteService, l as BUILTIN_FONT_THEMES, m as sqliteSchemaBundle, n as createNodeCliRuntime, o as getHostBasedStartupConfigurationIssues, p as pgSchemaBundle, r as createNodeRequestRuntime, s as createStorageDriver, t as createApp, u as getCjkSerifCssVariables } from "./app-C7CtIQM-.js";
 import { t as createExportService } from "./export-ZBlfKSKm.js";
 import { b as getSiteResolutionMode, i as getConfiguredSingleSitePathPrefix, l as getEnvString, r as getConfiguredSingleSiteOrigin, x as shouldTrustProxy, y as getPort } from "./env-CgaH9Mut.js";
 import "./github-sync-bL1hnx3Q.js";
@@ -474,7 +474,7 @@ async function createNodeRequestHandler(options) {
 async function start(env = process.env, app) {
 	const handler = await createNodeRequestHandler({
 		env,
-		app: async () => app ?? (await import("./app-DU7dpJID.js")).createApp()
+		app: async () => app ?? (await import("./app-CIx9SSOi.js")).createApp()
 	});
 	const hostname = resolveHost(env);
 	const port = resolvePort(env);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jant/core",
-  "version": "0.3.48",
+  "version": "0.3.50",
   "description": "A modern, open-source microblogging platform built on Cloudflare Workers",
   "type": "module",
   "exports": {

package/src/app.tsx

@@ -55,6 +55,7 @@ import {
 import { internalTextAttachmentsRoutes } from "./routes/api/internal/text-attachments.js";
 import { internalSearchReindexRoutes } from "./routes/api/internal/search-reindex.js";
 import { internalUploadsRoutes } from "./routes/api/internal/uploads.js";
+import { publicArchiveApiRoutes } from "./routes/api/public/archive.js";
 import { publicPostsApiRoutes } from "./routes/api/public/posts.js";
 // Routes - Compose
 import { composeRoutes } from "./routes/compose.js";
@@ -504,6 +505,7 @@ export function createApp(): App {
 
   // API Routes
   app.route("/api/public/posts", publicPostsApiRoutes);
+  app.route("/api/public/archive", publicArchiveApiRoutes);
   app.route("/api/posts", postsApiRoutes);
   app.route("/api/nav-items", navItemsApiRoutes);
   app.route("/api/collections", collectionsApiRoutes);

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

@@ -0,0 +1,261 @@
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../../__tests__/helpers/app.js";
+import { publicArchiveApiRoutes } from "../archive.js";
+
+describe("Public Archive API Routes", () => {
+  describe("GET /api/public/archive", () => {
+    it("includes latest_hidden posts but excludes private and drafts", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const publicRoot = await services.posts.create({
+        format: "note",
+        title: "Public root",
+        bodyMarkdown: "visible",
+      });
+      const hiddenRoot = await services.posts.create({
+        format: "note",
+        title: "Latest hidden root",
+        bodyMarkdown: "hidden from latest",
+        visibility: "latest_hidden",
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Private root",
+        bodyMarkdown: "private",
+        visibility: "private",
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Draft root",
+        bodyMarkdown: "draft",
+        status: "draft",
+      });
+      await services.posts.create({
+        format: "note",
+        bodyMarkdown: "reply",
+        replyToId: publicRoot.id,
+      });
+
+      const res = await app.request("/api/public/archive");
+      expect(res.status).toBe(200);
+
+      const body = await res.json();
+      expect(body.nextCursor).toBeNull();
+      expect(body.posts).toHaveLength(2);
+      const ids = body.posts.map((p: { id: string }) => p.id);
+      expect(ids).toContain(publicRoot.id);
+      expect(ids).toContain(hiddenRoot.id);
+      const hidden = body.posts.find(
+        (p: { id: string }) => p.id === hiddenRoot.id,
+      );
+      expect(hidden.visibility).toBe("latest_hidden");
+    });
+
+    it("supports format and limit filters with cursor", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      await services.posts.create({
+        format: "note",
+        title: "Note one",
+        bodyMarkdown: "first",
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Note two",
+        bodyMarkdown: "second",
+        visibility: "latest_hidden",
+      });
+      await services.posts.create({
+        format: "link",
+        title: "Example",
+        url: "https://example.com",
+      });
+
+      const res = await app.request("/api/public/archive?format=note&limit=1");
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.posts).toHaveLength(1);
+      expect(body.posts[0].format).toBe("note");
+      expect(body.nextCursor).toBeTruthy();
+
+      const next = await app.request(
+        `/api/public/archive?format=note&limit=1&cursor=${body.nextCursor}`,
+      );
+      const nextBody = await next.json();
+      expect(nextBody.posts).toHaveLength(1);
+      expect(nextBody.posts[0].id).not.toBe(body.posts[0].id);
+    });
+
+    it("filters by year using publishedAt", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const inYear = await services.posts.create({
+        format: "note",
+        title: "From 2024",
+        bodyMarkdown: "in",
+        publishedAt: Math.floor(Date.UTC(2024, 5, 1) / 1000),
+      });
+      await services.posts.create({
+        format: "note",
+        title: "From 2023",
+        bodyMarkdown: "out",
+        publishedAt: Math.floor(Date.UTC(2023, 5, 1) / 1000),
+      });
+
+      const res = await app.request("/api/public/archive?year=2024");
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.posts).toHaveLength(1);
+      expect(body.posts[0].id).toBe(inYear.id);
+    });
+
+    it("filters by hasTitle and hasMedia", 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?hasTitle=1");
+      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?hasTitle=0");
+      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?hasMedia=0");
+      const noMediaBody = await noMedia.json();
+      expect(noMediaBody.posts).toHaveLength(2);
+    });
+
+    it("filters by media kind", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const withImage = await services.posts.create({
+        format: "note",
+        title: "Image post",
+        bodyMarkdown: "image body",
+      });
+      const image = await services.media.create({
+        filename: "pic.jpg",
+        originalName: "pic.jpg",
+        mimeType: "image/jpeg",
+        size: 1024,
+        storageKey: "media/pic.jpg",
+      });
+      await services.media.attachToPost(withImage.id, [image.id]);
+
+      await services.posts.create({
+        format: "note",
+        title: "Plain post",
+        bodyMarkdown: "no media",
+      });
+
+      const res = await app.request("/api/public/archive?media=image");
+      const body = await res.json();
+      expect(body.posts).toHaveLength(1);
+      expect(body.posts[0].id).toBe(withImage.id);
+
+      const hasMediaRes = await app.request("/api/public/archive?hasMedia=1");
+      const hasMediaBody = await hasMediaRes.json();
+      expect(hasMediaBody.posts).toHaveLength(1);
+      expect(hasMediaBody.posts[0].id).toBe(withImage.id);
+    });
+
+    it("filters by collection (single and aggregate)", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const tech = await services.collections.create({
+        slug: "tech",
+        title: "Tech",
+      });
+      const art = await services.collections.create({
+        slug: "art",
+        title: "Art",
+      });
+      const techPost = await services.posts.create({
+        format: "note",
+        title: "Tech",
+        bodyMarkdown: "t",
+        collectionIds: [tech.id],
+      });
+      const artPost = await services.posts.create({
+        format: "note",
+        title: "Art",
+        bodyMarkdown: "a",
+        collectionIds: [art.id],
+        visibility: "latest_hidden",
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Other",
+        bodyMarkdown: "o",
+      });
+
+      const single = await app.request("/api/public/archive?collection=tech");
+      const singleBody = await single.json();
+      expect(singleBody.posts.map((p: { id: string }) => p.id)).toEqual([
+        techPost.id,
+      ]);
+
+      const aggregate = await app.request(
+        "/api/public/archive?collection=tech,art",
+      );
+      const aggregateBody = await aggregate.json();
+      const aggregateIds = aggregateBody.posts.map((p: { id: string }) => p.id);
+      expect(aggregateIds).toContain(techPost.id);
+      expect(aggregateIds).toContain(artPost.id);
+      expect(aggregateBody.posts).toHaveLength(2);
+
+      const unknown = await app.request(
+        "/api/public/archive?collection=nonexistent",
+      );
+      const unknownBody = await unknown.json();
+      expect(unknownBody.posts).toEqual([]);
+      expect(unknownBody.nextCursor).toBeNull();
+    });
+
+    it("returns markdown instead of rendered fields when content=markdown", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      await services.posts.create({
+        format: "note",
+        title: "Markdown post",
+        bodyMarkdown: "# Hello\n\nBody",
+      });
+
+      const res = await app.request("/api/public/archive?content=markdown");
+      const body = await res.json();
+      expect(body.posts).toHaveLength(1);
+      expect(body.posts[0].bodyMarkdown).toBe("# Hello\n\nBody");
+      expect(body.posts[0]).not.toHaveProperty("bodyHtml");
+      expect(body.posts[0]).not.toHaveProperty("bodyText");
+    });
+
+    it("rejects invalid media kind", async () => {
+      const { app } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const res = await app.request("/api/public/archive?media=invalid");
+      expect(res.status).toBe(400);
+    });
+  });
+});

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

@@ -0,0 +1,116 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import type { Bindings } from "../../../types.js";
+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";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+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 BoolFlagSchema = z.enum(["0", "1"]).transform((value) => value === "1");
+
+const ListPublicArchiveQuerySchema = z.object({
+  format: FormatSchema.optional(),
+  collection: z.string().optional(),
+  year: z.coerce.number().int().min(1971).optional(),
+  media: z
+    .string()
+    .optional()
+    .transform((value, ctx) => {
+      if (!value) return undefined;
+      const parts = value
+        .split(",")
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+      if (parts.length === 0) return undefined;
+      const result = z.array(MediaKindSchema).safeParse(parts);
+      if (!result.success) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: INVALID_MEDIA_KIND_MESSAGE,
+        });
+        return z.NEVER;
+      }
+      return result.data;
+    }),
+  hasMedia: BoolFlagSchema.optional(),
+  hasTitle: BoolFlagSchema.optional(),
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).optional().default(20),
+  content: z.enum(["markdown"]).optional(),
+});
+
+publicArchiveApiRoutes.get("/", async (c) => {
+  const {
+    format,
+    collection,
+    year,
+    media,
+    hasMedia,
+    hasTitle,
+    cursor,
+    limit,
+    content,
+  } = parseValidated(ListPublicArchiveQuerySchema, c.req.query());
+
+  let collectionIds: string[] | undefined;
+  if (collection) {
+    // Accept both "tech,art" and "tech+art", matching the page URL convention.
+    const slugExpression = collection.replace(/,/g, "+");
+    const selection =
+      await c.var.services.collections.resolveSelection(slugExpression);
+    if (!selection || selection.collections.length === 0) {
+      return c.json({ posts: [], nextCursor: null });
+    }
+    collectionIds = selection.collections.map((col) => col.id);
+  }
+
+  const publishedAfter =
+    year !== undefined ? Date.UTC(year, 0, 1) / 1000 : undefined;
+  const publishedBefore =
+    year !== undefined ? Date.UTC(year + 1, 0, 1) / 1000 : undefined;
+
+  const posts = await c.var.services.posts.list({
+    format,
+    collectionIds,
+    status: "published",
+    cursor: cursor ?? undefined,
+    limit,
+    excludePrivate: true,
+    excludeLatestHidden: false,
+    excludeReplies: true,
+    publishedAfter,
+    publishedBefore,
+    mediaKinds: media,
+    hasMedia,
+    hasTitle,
+  });
+
+  const postIds = posts.map((post) => post.id);
+  const [mediaMap, collectionsMap] = await Promise.all([
+    c.var.services.media.getByPostIds(postIds),
+    c.var.services.collections.getCollectionsByPostIds(postIds),
+  ]);
+
+  return c.json({
+    posts: posts.map((post) =>
+      toPublicPost(
+        post,
+        mediaMap.get(post.id) ?? [],
+        collectionsMap.get(post.id) ?? [],
+        c.var.appConfig,
+        { content },
+      ),
+    ),
+    nextCursor:
+      posts.length === limit ? (posts[posts.length - 1]?.id ?? null) : null,
+  });
+});

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

@@ -39,7 +39,7 @@ const PublicPostContentQuerySchema = z.object({
   content: z.enum(["markdown"]).optional(),
 });
 
-type PublicPostBaseResponse = {
+export type PublicPostBaseResponse = {
   id: string;
   format: Post["format"];
   status: "published";
@@ -73,16 +73,16 @@ type PublicPostBaseResponse = {
   }[];
 };
 
-type PublicPostRenderedResponse = PublicPostBaseResponse & {
+export type PublicPostRenderedResponse = PublicPostBaseResponse & {
   bodyHtml: string | null;
   bodyText: string | null;
 };
 
-type PublicPostMarkdownResponse = PublicPostBaseResponse & {
+export type PublicPostMarkdownResponse = PublicPostBaseResponse & {
   bodyMarkdown: string | null;
 };
 
-type PublicPostResponse =
+export type PublicPostResponse =
   | PublicPostRenderedResponse
   | PublicPostMarkdownResponse;
 
@@ -94,7 +94,7 @@ function isPublicDetailVisible(post: Post | null): post is Post {
   );
 }
 
-function toPublicPost(
+export function toPublicPost(
   post: Post,
   mediaList: Media[],
   postCollections: Collection[],

package/src/ui/shared/MediaGallery.tsx

@@ -64,7 +64,7 @@ export function getMediaPlaceholderDataUrl(
 }
 
 function getSingleVisualWidth(ratio: number): string {
-  return `min(100%, calc(24rem * ${ratio}))`;
+  return `min(100%, calc(24rem * ${ratio}), var(--layout-content-width))`;
 }
 
 /**

package/src/ui/shared/__tests__/media-gallery.test.ts

@@ -50,7 +50,9 @@ describe("MediaGallery", () => {
     );
 
     expect(html).toContain("aspect-ratio:900/1600");
-    expect(html).toMatch(/width:min\(100%, ?calc\(24rem ?\* ?0\.5625\)\)/);
+    expect(html).toMatch(
+      /width:min\(100%, ?calc\(24rem ?\* ?0\.5625\), ?var\(--layout-content-width\)\)/,
+    );
     expect(html).not.toContain("object-contain");
   });