@jant/core 0.6.1 → 0.6.3

package/dist/{github-api-Bh0PH3zr.js → github-api-UD4u_7fa.js}

@@ -1,4 +1,4 @@
-import { v as __exportAll } from "./url-umUptr5z.js";
+import { y as __exportAll } from "./url-XF0GbKGO.js";
 //#region src/lib/github-api.ts
 var github_api_exports = /* @__PURE__ */ __exportAll({
 	GitHubApiError: () => GitHubApiError,

package/dist/{github-app-D0GvNnqp.js → github-app-DeX6Td1O.js}

@@ -1,4 +1,4 @@
-import { v as __exportAll } from "./url-umUptr5z.js";
+import { y as __exportAll } from "./url-XF0GbKGO.js";
 //#region src/lib/github-app.ts
 var github_app_exports = /* @__PURE__ */ __exportAll({
 	buildInstallUrl: () => buildInstallUrl,

package/dist/{github-sync-dXsiZa_e.js → github-sync-CerNYCAn.js}

@@ -1,4 +1,4 @@
-import "./url-umUptr5z.js";
-import "./export-Bbn86HmS.js";
-import { i as classifyRepoForSync, o as createGitHubSyncService } from "./github-sync-CBQPRZ8H.js";
+import "./url-XF0GbKGO.js";
+import "./export-CzuQyg5h.js";
+import { i as classifyRepoForSync, o as createGitHubSyncService } from "./github-sync-Dbrb1DS5.js";
 export { classifyRepoForSync, createGitHubSyncService };

package/dist/{github-sync-CBQPRZ8H.js → github-sync-Dbrb1DS5.js}

@@ -1,6 +1,6 @@
-import { c as parseMarkdownDocument, r as parseFrontMatter, t as createExportService } from "./export-Bbn86HmS.js";
-import { r as getInstallationToken } from "./github-app-D0GvNnqp.js";
-import { r as parseRepoSlug, t as createGitHubClient } from "./github-api-Bh0PH3zr.js";
+import { c as parseMarkdownDocument, r as parseFrontMatter, t as createExportService } from "./export-CzuQyg5h.js";
+import { r as getInstallationToken } from "./github-app-DeX6Td1O.js";
+import { r as parseRepoSlug, t as createGitHubClient } from "./github-api-UD4u_7fa.js";
 //#region src/lib/markdown-to-tiptap.ts
 /**
 * Markdown → TipTap JSON Conversion
@@ -274,7 +274,10 @@ function createGitHubSyncService(services, siteId, siteConfig, deps = {}) {
 			const config = await loadConfig();
 			if (!config) throw new Error("GitHub Sync is not configured");
 			const { client, owner, repo } = createClient(config);
-			const exportFiles = await createExportService(services, siteConfig, deps).generateHugoFiles();
+			const exportFiles = await createExportService(services, siteConfig, {
+				storage: deps.storage,
+				bundleMedia: false
+			}).generateHugoFiles();
 			const defaultBranch = (await client.getRepo(owner, repo)).default_branch;
 			const now = Math.floor(Date.now() / 1e3);
 			const existingMarkerBeforeInit = await client.getFileContent(owner, repo, JANT_SYNC_MARKER_PATH).catch(() => null);

package/dist/index.js

@@ -1,6 +1,6 @@
-import { _ as url_exports } from "./url-umUptr5z.js";
-import { A as MAX_MEDIA_ATTACHMENTS, C as toMediaView, D as toPostViews, E as toPostView, F as STATUSES, I as TEXT_ATTACHMENT_CONTENT_FORMATS, M as MEDIA_KINDS, N as NAV_ITEM_TYPES, O as toSearchResultView, P as SORT_ORDERS, S as toArchiveGroupsWithMedia, T as toNavItemViews, b as createMediaContext, h as defaultFeedRenderer, j as MAX_PINNED_POSTS, k as FORMATS, t as createApp, w as toNavItemView, x as toArchiveGroups } from "./app-DYQdDMs8.js";
-import { T as time_exports, a as markdown_exports } from "./export-Bbn86HmS.js";
-import "./env-C7e2Nlnt.js";
-import "./github-sync-CBQPRZ8H.js";
+import { v as url_exports } from "./url-XF0GbKGO.js";
+import { A as MAX_MEDIA_ATTACHMENTS, C as toMediaView, D as toPostViews, E as toPostView, F as STATUSES, I as TEXT_ATTACHMENT_CONTENT_FORMATS, M as MEDIA_KINDS, N as NAV_ITEM_TYPES, O as toSearchResultView, P as SORT_ORDERS, S as toArchiveGroupsWithMedia, T as toNavItemViews, b as createMediaContext, h as defaultFeedRenderer, j as MAX_PINNED_POSTS, k as FORMATS, t as createApp, w as toNavItemView, x as toArchiveGroups } from "./app-CyysIxj_.js";
+import { T as time_exports, a as markdown_exports } from "./export-CzuQyg5h.js";
+import "./env-CoSe-1y4.js";
+import "./github-sync-Dbrb1DS5.js";
 export { FORMATS, MAX_MEDIA_ATTACHMENTS, MAX_PINNED_POSTS, MEDIA_KINDS, NAV_ITEM_TYPES, SORT_ORDERS, STATUSES, TEXT_ATTACHMENT_CONTENT_FORMATS, createApp, createMediaContext, defaultFeedRenderer, markdown_exports as markdown, time_exports as time, toArchiveGroups, toArchiveGroupsWithMedia, toMediaView, toNavItemView, toNavItemViews, toPostView, toPostViews, toSearchResultView, url_exports as url };

package/dist/node.js

@@ -1,8 +1,8 @@
-import "./url-umUptr5z.js";
-import { B as isAssetPath, L as buildThemeStyle, R as BUILTIN_COLOR_THEMES, _ as sqliteSchemaBundle, a as resolveDatabaseDialect, c as resolveConfig, d as setWebhook, f as BUILTIN_FONT_THEMES, g as pgSchemaBundle, i as createSiteService, l as getWebhookUrl, m as getFontThemeCssVariables, n as createNodeCliRuntime, o as getHostBasedStartupConfigurationIssues, p as getCjkSerifCssVariables, r as createNodeRequestRuntime, s as createStorageDriver, t as createApp, u as setMyCommands, v as createNodeDatabase, y as schema_exports, z as getPublicAssetBasePath } from "./app-DYQdDMs8.js";
-import { t as createExportService } from "./export-Bbn86HmS.js";
-import { C as shouldTrustProxy, S as getTelegramWebhookSecret, b as getSiteResolutionMode, d as getHostedControlPlaneBaseUrl, i as getConfiguredSingleSitePathPrefix, l as getEnvString, r as getConfiguredSingleSiteOrigin, x as getTelegramBotPool, y as getPort } from "./env-C7e2Nlnt.js";
-import "./github-sync-CBQPRZ8H.js";
+import "./url-XF0GbKGO.js";
+import { B as isAssetPath, L as buildThemeStyle, R as BUILTIN_COLOR_THEMES, _ as sqliteSchemaBundle, a as resolveDatabaseDialect, c as resolveConfig, d as setWebhook, f as BUILTIN_FONT_THEMES, g as pgSchemaBundle, i as createSiteService, l as getWebhookUrl, m as getFontThemeCssVariables, n as createNodeCliRuntime, o as getHostBasedStartupConfigurationIssues, p as getCjkSerifCssVariables, r as createNodeRequestRuntime, s as createStorageDriver, t as createApp, u as setMyCommands, v as createNodeDatabase, y as schema_exports, z as getPublicAssetBasePath } from "./app-CyysIxj_.js";
+import { t as createExportService } from "./export-CzuQyg5h.js";
+import { C as shouldTrustProxy, S as getTelegramWebhookSecret, b as getSiteResolutionMode, d as getHostedControlPlaneBaseUrl, i as getConfiguredSingleSitePathPrefix, l as getEnvString, r as getConfiguredSingleSiteOrigin, x as getTelegramBotPool, y as getPort } from "./env-CoSe-1y4.js";
+import "./github-sync-Dbrb1DS5.js";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { serve } from "@hono/node-server";
 import Database from "better-sqlite3";
@@ -529,7 +529,7 @@ async function createNodeRequestHandler(options) {
 async function start(env = process.env, app) {
 	const handler = await createNodeRequestHandler({
 		env,
-		app: async () => app ?? (await import("./app-CMSW_AYG.js")).createApp()
+		app: async () => app ?? (await import("./app-BX2XKxq0.js")).createApp()
 	});
 	const hostname = resolveHost(env);
 	const port = resolvePort(env);

package/dist/{url-umUptr5z.js → url-XF0GbKGO.js}

@@ -29,6 +29,7 @@ var __exportAll = (all, no_symbols) => {
 	sanitizeUrl: () => sanitizeUrl,
 	slugify: () => slugify,
 	stripSitePathPrefix: () => stripSitePathPrefix,
+	toAbsoluteAssetUrl: () => toAbsoluteAssetUrl,
 	toAbsoluteSiteUrl: () => toAbsoluteSiteUrl,
 	toPublicHref: () => toPublicHref,
 	toPublicPath: () => toPublicPath
@@ -330,5 +331,25 @@ var SAFE_URL_PROTOCOLS = new Set([
 	if (!siteUrl) return toPublicPath(path, sitePathPrefix);
 	return new URL(toPublicPath(path, sitePathPrefix), siteUrl).toString();
 }
+/**
+* Resolve a possibly-relative asset URL to an absolute URL, leaving
+* already-absolute (`http(s):`) and protocol-relative (`//host`) URLs
+* untouched. Use for assets — like media — whose stored URL may be either an
+* app-local path or a full CDN URL.
+*
+* @param url - Asset URL: an internal path or an already-absolute URL
+* @param siteUrl - Normalized site URL
+* @param sitePathPrefix - Public site path prefix
+* @returns Absolute URL, or the original value when it is already absolute
+*
+* @example
+* ```ts
+* toAbsoluteAssetUrl("/m/a.png", "https://site.com");   // "https://site.com/m/a.png"
+* toAbsoluteAssetUrl("https://cdn.example/a.png", "x"); // "https://cdn.example/a.png"
+* ```
+*/ function toAbsoluteAssetUrl(url, siteUrl, sitePathPrefix = "") {
+	if (isFullUrl(url) || url.startsWith("//")) return url;
+	return toAbsoluteSiteUrl(url, siteUrl, sitePathPrefix);
+}
 //#endregion
-export { url_exports as _, getSitePathPrefix as a, normalizePath as c, sanitizeUrl as d, slugify as f, toPublicPath as g, toPublicHref as h, getSiteOrigin as i, normalizeSitePathPrefix as l, toAbsoluteSiteUrl as m, extractDisplayDomain as n, isFullUrl as o, stripSitePathPrefix as p, extractDomain as r, isSafeInternalRedirect as s, buildSiteUrl as t, normalizeSiteUrl as u, __exportAll as v };
+export { toPublicPath as _, getSitePathPrefix as a, normalizePath as c, sanitizeUrl as d, slugify as f, toPublicHref as g, toAbsoluteSiteUrl as h, getSiteOrigin as i, normalizeSitePathPrefix as l, toAbsoluteAssetUrl as m, extractDisplayDomain as n, isFullUrl as o, stripSitePathPrefix as p, extractDomain as r, isSafeInternalRedirect as s, buildSiteUrl as t, normalizeSiteUrl as u, url_exports as v, __exportAll as y };

package/package.json

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

package/src/__tests__/export-service.test.ts

@@ -800,4 +800,131 @@ describe("createExportService (Hugo)", () => {
     const files = filesToMap(await service.generateHugoFiles());
     expect(files.has("static/media/med-x.webp")).toBe(false);
   });
+
+  it("Sync mode (bundleMedia false) links media by absolute site URL without reading bytes", async () => {
+    const root = makePost({ id: "post-root", slug: "with-media" });
+    const media = makeMedia({
+      id: "med-1",
+      filename: "photo.webp",
+      storageKey: "media/med-1.webp",
+    });
+    const storage = {
+      // Must NOT be called — Sync links by URL, never reads attachment bytes.
+      get: async () => {
+        throw new Error("storage.get should not be called in Sync mode");
+      },
+    };
+    const service = createExportService(
+      buildServices({
+        posts: [root],
+        mediaByPost: new Map([["post-root", [media]]]),
+      }),
+      makeSiteConfig(),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      { storage: storage as any, bundleMedia: false },
+    );
+    const files = filesToMap(await service.generateHugoFiles());
+    expect(files.has("static/media/med-1.webp")).toBe(false);
+    const { frontMatter } = await parseFrontMatter(
+      files.get("content/with-media/_index.md") as string,
+    );
+    const entry = frontMatter.media![0];
+    expect(entry.src).toBe("https://example.com/media/med-1.webp");
+    expect(entry.storage_key).toBe("media/med-1.webp");
+  });
+
+  it("Sync mode links the video poster by absolute site URL without bundling", async () => {
+    const root = makePost({ id: "post-root", slug: "with-video" });
+    const videoMedia = makeMedia({
+      id: "med-video",
+      filename: "clip.mp4",
+      mimeType: "video/mp4",
+      storageKey: "media/med-video.mp4",
+      mediaKind: "video",
+      posterKey: "media/posters/med-video.webp",
+    });
+    const storage = {
+      get: async () => {
+        throw new Error("storage.get should not be called in Sync mode");
+      },
+    };
+    const service = createExportService(
+      buildServices({
+        posts: [root],
+        mediaByPost: new Map([["post-root", [videoMedia]]]),
+      }),
+      makeSiteConfig(),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      { storage: storage as any, bundleMedia: false },
+    );
+    const files = filesToMap(await service.generateHugoFiles());
+    expect(files.has("static/media/med-video.mp4")).toBe(false);
+    expect(files.has("static/media/med-video-poster.webp")).toBe(false);
+    const { frontMatter } = await parseFrontMatter(
+      files.get("content/with-video/_index.md") as string,
+    );
+    const entry = frontMatter.media![0];
+    expect(entry.src).toBe("https://example.com/media/med-video.mp4");
+    expect(entry.poster).toBe(
+      "https://example.com/media/posters/med-video.webp",
+    );
+  });
+
+  it("Sync mode still prefers a dedicated provider public URL when configured", async () => {
+    const root = makePost({ id: "post-root", slug: "with-cdn" });
+    const media = makeMedia({
+      id: "med-cdn",
+      filename: "cdn.webp",
+      storageKey: "media/med-cdn.webp",
+    });
+    const service = createExportService(
+      buildServices({
+        posts: [root],
+        mediaByPost: new Map([["post-root", [media]]]),
+      }),
+      makeSiteConfig({ r2PublicUrl: "https://cdn.example.com" }),
+      { bundleMedia: false },
+    );
+    const files = filesToMap(await service.generateHugoFiles());
+    expect(files.has("static/media/med-cdn.webp")).toBe(false);
+    const { frontMatter } = await parseFrontMatter(
+      files.get("content/with-cdn/_index.md") as string,
+    );
+    expect(frontMatter.media![0].src).toBe(
+      "https://cdn.example.com/media/med-cdn.webp",
+    );
+  });
+
+  it("Sync mode falls back to bundling bytes when the site URL is unknown", async () => {
+    const root = makePost({ id: "post-root", slug: "with-media" });
+    const media = makeMedia({
+      id: "med-1",
+      filename: "photo.webp",
+      storageKey: "media/med-1.webp",
+    });
+    const storage = {
+      get: async (key: string) =>
+        key === "media/med-1.webp"
+          ? { body: new Blob([new Uint8Array([1, 2, 3])]).stream() }
+          : null,
+    };
+    const service = createExportService(
+      buildServices({
+        posts: [root],
+        mediaByPost: new Map([["post-root", [media]]]),
+      }),
+      makeSiteConfig({ siteUrl: "" }),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      { storage: storage as any, bundleMedia: false },
+    );
+    const files = filesToMap(await service.generateHugoFiles());
+    // No resolvable URL — bundling is the only way to avoid a broken link.
+    expect(files.get("static/media/med-1.webp")).toEqual(
+      new Uint8Array([1, 2, 3]),
+    );
+    const { frontMatter } = await parseFrontMatter(
+      files.get("content/with-media/_index.md") as string,
+    );
+    expect(frontMatter.media![0].src).toBe("/media/med-1.webp");
+  });
 });

package/src/client/__tests__/image-processor.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { planImageProcessing } from "../image-processor.js";
+
+const OPTS = { maxShortSide: 1920, maxLongSide: 8192 };
+
+describe("planImageProcessing", () => {
+  it("leaves small images untouched", () => {
+    expect(planImageProcessing(800, 600, OPTS)).toEqual({
+      passthrough: false,
+      width: 800,
+      height: 600,
+    });
+  });
+
+  it("keeps long screenshots at full resolution", () => {
+    expect(planImageProcessing(1080, 6000, OPTS)).toEqual({
+      passthrough: false,
+      width: 1080,
+      height: 6000,
+    });
+  });
+
+  it("keeps wide screenshots at full resolution", () => {
+    expect(planImageProcessing(6000, 1080, OPTS)).toEqual({
+      passthrough: false,
+      width: 6000,
+      height: 1080,
+    });
+  });
+
+  it("downscales a large photo by its short side, not its long side", () => {
+    const plan = planImageProcessing(4032, 3024, OPTS);
+    expect(plan.passthrough).toBe(false);
+    expect(plan.height).toBe(1920);
+    expect(plan.width).toBe(Math.round(4032 * (1920 / 3024)));
+  });
+
+  it("caps the short side regardless of orientation", () => {
+    const portrait = planImageProcessing(3024, 4032, OPTS);
+    expect(portrait.width).toBe(1920);
+    expect(portrait.height).toBe(Math.round(4032 * (1920 / 3024)));
+  });
+
+  it("uploads images taller than the canvas limit untouched", () => {
+    expect(planImageProcessing(1080, 12000, OPTS)).toEqual({
+      passthrough: true,
+      width: 1080,
+      height: 12000,
+    });
+  });
+
+  it("uploads images wider than the canvas limit untouched", () => {
+    expect(planImageProcessing(12000, 1080, OPTS)).toEqual({
+      passthrough: true,
+      width: 12000,
+      height: 1080,
+    });
+  });
+
+  it("treats the long-side cap as inclusive", () => {
+    expect(planImageProcessing(1080, 8192, OPTS).passthrough).toBe(false);
+    expect(planImageProcessing(1080, 8193, OPTS).passthrough).toBe(true);
+  });
+});

package/src/client/components/__tests__/jant-collection-directory.test.ts

@@ -24,8 +24,6 @@ import type { JantCollectionsManager } from "../jant-collection-directory.js";
 
 const labels: CollectionManagerLabels = {
   collectionsTitle: "Collections",
-  collectionSingular: "collection",
-  collectionPlural: "collections",
   organize: "Organize",
   done: "Done",
   organizeHint: "Drag to reorder.",
@@ -186,7 +184,6 @@ async function createElementWithManagerRoot(): Promise<JantCollectionsManager> {
   const root = document.createElement("div");
   root.setAttribute("data-collections-manager-root", "");
   root.innerHTML = `
-    <p data-collections-count></p>
     <div data-collections-reorder-actions hidden>
       <button type="button" data-collections-action="divider">New divider</button>
       <button type="button" data-collections-action="done">Done</button>
@@ -208,32 +205,6 @@ async function createElementWithManagerRoot(): Promise<JantCollectionsManager> {
   return el;
 }
 
-async function createEmptyElementWithManagerRoot(): Promise<JantCollectionsManager> {
-  const root = document.createElement("div");
-  root.setAttribute("data-collections-manager-root", "");
-  root.innerHTML = `
-    <p data-collections-count hidden></p>
-    <div data-collections-reorder-actions hidden>
-      <button type="button" data-collections-action="divider">New divider</button>
-      <button type="button" data-collections-action="done">Done</button>
-    </div>
-    <div data-collections-toolbar></div>
-    <p data-collections-hint hidden></p>
-    <div data-collections-more-menu hidden></div>
-    <button type="button" data-collections-action="toggle-menu"></button>
-  `;
-
-  const el = document.createElement(
-    "jant-collections-manager",
-  ) as JantCollectionsManager;
-  el.labels = labels;
-  el.items = [];
-  root.appendChild(el);
-  document.body.appendChild(root);
-  await el.updateComplete;
-  return el;
-}
-
 describe("JantCollectionsManager", () => {
   beforeEach(() => {
     document.body.innerHTML = "";
@@ -308,19 +279,6 @@ describe("JantCollectionsManager", () => {
     expect(toolbar?.hidden).toBe(true);
   });
 
-  it("keeps the collection count visible when the list is empty", async () => {
-    const el = await createEmptyElementWithManagerRoot();
-    const root = el.closest<HTMLElement>("[data-collections-manager-root]");
-
-    expect(root).not.toBeNull();
-    if (!root) throw new Error("Expected collections manager root");
-
-    const count = root.querySelector<HTMLElement>("[data-collections-count]");
-
-    expect(count?.hidden).toBe(false);
-    expect(count?.textContent).toBe("0 collections");
-  });
-
   it("renders divider labels as aggregate links when followed by a grouped section", async () => {
     const el = await createElementWithItems(groupedItems);
 

package/src/client/components/__tests__/jant-media-lightbox.test.ts

@@ -94,7 +94,7 @@ describe("JantMediaLightbox", () => {
     ).toBe(false);
   });
 
-  it("renders tall images in a scrollable stage", async () => {
+  it("previews tall images contained, then expands to a scrollable stage on click", async () => {
     const el = await createElement();
 
     el.open(
@@ -110,14 +110,67 @@ describe("JantMediaLightbox", () => {
     );
     await flush(el);
 
-    const stage = el.querySelector(".media-lightbox-stage");
-    const img = el.querySelector(".media-lightbox-img");
+    const initialStage = el.querySelector(".media-lightbox-stage");
+    const initialImg = el.querySelector<HTMLImageElement>(
+      ".media-lightbox-img",
+    );
 
-    expect(stage?.classList.contains("media-lightbox-stage-scroll")).toBe(true);
-    expect(img?.classList.contains("media-lightbox-img-scroll")).toBe(true);
+    expect(
+      initialStage?.classList.contains("media-lightbox-stage-scroll"),
+    ).toBe(false);
+    expect(initialImg?.classList.contains("media-lightbox-img-scroll")).toBe(
+      false,
+    );
+    expect(initialImg?.classList.contains("media-lightbox-img-zoomable")).toBe(
+      true,
+    );
+
+    initialImg?.dispatchEvent(
+      new MouseEvent("click", { bubbles: true, cancelable: true }),
+    );
+    await flush(el);
+
+    const zoomedStage = el.querySelector(".media-lightbox-stage");
+    const zoomedImg = el.querySelector(".media-lightbox-img");
+    expect(zoomedStage?.classList.contains("media-lightbox-stage-scroll")).toBe(
+      true,
+    );
+    expect(zoomedImg?.classList.contains("media-lightbox-img-scroll")).toBe(
+      true,
+    );
+
+    zoomedImg?.dispatchEvent(
+      new MouseEvent("click", { bubbles: true, cancelable: true }),
+    );
+    await flush(el);
+
+    const collapsedStage = el.querySelector(".media-lightbox-stage");
+    expect(
+      collapsedStage?.classList.contains("media-lightbox-stage-scroll"),
+    ).toBe(false);
   });
 
-  it("resets stage scroll when navigating between images", async () => {
+  it("does not show the zoom affordance for regular-aspect images", async () => {
+    const el = await createElement();
+
+    el.open(
+      [
+        {
+          url: "https://example.com/wide.jpg",
+          alt: "",
+          width: 1600,
+          height: 900,
+        },
+      ],
+      0,
+    );
+    await flush(el);
+
+    const img = el.querySelector(".media-lightbox-img");
+    expect(img?.classList.contains("media-lightbox-img-zoomable")).toBe(false);
+  });
+
+  it("resets zoom and stage scroll when navigating between images", async () => {
     const el = await createElement();
 
     el.open(
@@ -139,10 +192,18 @@ describe("JantMediaLightbox", () => {
     );
     await flush(el);
 
+    el.querySelector<HTMLImageElement>(".media-lightbox-img")?.dispatchEvent(
+      new MouseEvent("click", { bubbles: true, cancelable: true }),
+    );
+    await flush(el);
+
     const initialStage = el.querySelector<HTMLElement>(".media-lightbox-stage");
     if (!initialStage) {
       throw new Error("expected lightbox stage");
     }
+    expect(initialStage.classList.contains("media-lightbox-stage-scroll")).toBe(
+      true,
+    );
     initialStage.scrollTop = 180;
 
     el.querySelector<HTMLButtonElement>(".media-lightbox-nav-next")?.click();
@@ -150,6 +211,9 @@ describe("JantMediaLightbox", () => {
 
     const nextStage = el.querySelector<HTMLElement>(".media-lightbox-stage");
     expect(nextStage?.scrollTop).toBe(0);
+    expect(nextStage?.classList.contains("media-lightbox-stage-scroll")).toBe(
+      false,
+    );
   });
 
   it("uses natural image dimensions for inline post-body images", async () => {
@@ -179,8 +243,15 @@ describe("JantMediaLightbox", () => {
     );
     await flush(el);
 
-    const stage = el.querySelector(".media-lightbox-stage");
-    expect(stage?.classList.contains("media-lightbox-stage-scroll")).toBe(true);
+    const lightboxImg = el.querySelector<HTMLImageElement>(
+      ".media-lightbox-img",
+    );
+    expect(lightboxImg?.classList.contains("media-lightbox-img-zoomable")).toBe(
+      true,
+    );
+    expect(lightboxImg?.classList.contains("media-lightbox-img-scroll")).toBe(
+      false,
+    );
   });
 
   it("renders custom controls for short videos", async () => {

package/src/client/components/collection-manager-types.ts

@@ -6,8 +6,6 @@ import type { CollectionFormLabels } from "./collection-types.js";
 
 export interface CollectionManagerLabels {
   collectionsTitle: string;
-  collectionSingular: string;
-  collectionPlural: string;
   organize: string;
   done: string;
   organizeHint: string;

package/src/client/components/jant-collection-directory.ts

@@ -245,21 +245,6 @@ export class JantCollectionsManager extends LitElement {
     );
   }
 
-  #collectionCount() {
-    return this._items.filter(
-      (item) => item.type === "collection" && item.collection,
-    ).length;
-  }
-
-  #collectionCountLabel() {
-    const count = this.#collectionCount();
-    return `${count} ${
-      count === 1
-        ? this.labels.collectionSingular
-        : this.labels.collectionPlural
-    }`;
-  }
-
   #countLabel(count: number) {
     return `${count} ${
       count === 1 ? this.labels.entrySingular : this.labels.entryPlural
@@ -280,14 +265,6 @@ export class JantCollectionsManager extends LitElement {
   }
 
   #syncHeaderState() {
-    const countEl = this.#queryHeaderElement<HTMLElement>(
-      "[data-collections-count]",
-    );
-    if (countEl) {
-      countEl.textContent = this.#collectionCountLabel();
-      countEl.hidden = false;
-    }
-
     const doneButton = this.#queryHeaderElement<HTMLButtonElement>(
       '[data-collections-action="done"]',
     );

package/src/client/components/jant-compose-editor.ts

@@ -2524,9 +2524,9 @@ export class JantComposeEditor extends LitElement {
           : this.format === "link"
             ? this._renderLinkFields()
             : this._renderQuoteFields()}
-        ${this._renderStarRating()}
       </section>
-      ${this._renderAttachmentDock()} ${this._renderToolsRow()}
+      ${this._renderAttachmentDock()} ${this._renderStarRating()}
+      ${this._renderToolsRow()}
     `;
   }
 }