emdash 0.1.0 → 0.1.1

package/src/cli/commands/schema.ts

@@ -8,7 +8,7 @@ import { defineCommand } from "citty";
 import { consola } from "consola";
 
 import { connectionArgs as commonArgs, createClientFromArgs } from "../client-factory.js";
-import { output } from "../output.js";
+import { configureOutputMode, output } from "../output.js";
 
 const listCommand = defineCommand({
 	meta: {
@@ -19,6 +19,7 @@ const listCommand = defineCommand({
 		...commonArgs,
 	},
 	async run({ args }) {
+		configureOutputMode(args);
 		try {
 			const client = createClientFromArgs(args);
 			const collections = await client.collections();
@@ -44,6 +45,7 @@ const getCommand = defineCommand({
 		...commonArgs,
 	},
 	async run({ args }) {
+		configureOutputMode(args);
 		try {
 			const client = createClientFromArgs(args);
 			const collection = await client.collection(args.collection);
@@ -82,6 +84,7 @@ const createCommand = defineCommand({
 		...commonArgs,
 	},
 	async run({ args }) {
+		configureOutputMode(args);
 		try {
 			const client = createClientFromArgs(args);
 			const data = await client.createCollection({
@@ -117,6 +120,7 @@ const deleteCommand = defineCommand({
 		...commonArgs,
 	},
 	async run({ args }) {
+		configureOutputMode(args);
 		try {
 			if (!args.force) {
 				const confirmed = await consola.prompt(`Delete collection "${args.collection}"?`, {
@@ -170,6 +174,7 @@ const addFieldCommand = defineCommand({
 		...commonArgs,
 	},
 	async run({ args }) {
+		configureOutputMode(args);
 		try {
 			const client = createClientFromArgs(args);
 			const data = await client.createField(args.collection, {
@@ -206,6 +211,7 @@ const removeFieldCommand = defineCommand({
 		...commonArgs,
 	},
 	async run({ args }) {
+		configureOutputMode(args);
 		try {
 			const client = createClientFromArgs(args);
 			await client.deleteField(args.collection, args.field);

package/src/cli/commands/search-cmd.ts

@@ -8,7 +8,7 @@ import { defineCommand } from "citty";
 import { consola } from "consola";
 
 import { connectionArgs, createClientFromArgs } from "../client-factory.js";
-import { output } from "../output.js";
+import { configureOutputMode, output } from "../output.js";
 
 export const searchCommand = defineCommand({
 	meta: {
@@ -38,6 +38,7 @@ export const searchCommand = defineCommand({
 		...connectionArgs,
 	},
 	async run({ args }) {
+		configureOutputMode(args);
 		try {
 			const client = createClientFromArgs(args);
 			const results = await client.search(args.query, {

package/src/cli/commands/taxonomy.ts

@@ -8,7 +8,7 @@ import { defineCommand } from "citty";
 import { consola } from "consola";
 
 import { connectionArgs, createClientFromArgs } from "../client-factory.js";
-import { output } from "../output.js";
+import { configureOutputMode, output } from "../output.js";
 
 /** Pattern to replace whitespace with hyphens for slug generation */
 const WHITESPACE_PATTERN = /\s+/g;
@@ -22,6 +22,7 @@ const listCommand = defineCommand({
 		...connectionArgs,
 	},
 	async run({ args }) {
+		configureOutputMode(args);
 		try {
 			const client = createClientFromArgs(args);
 			const taxonomies = await client.taxonomies();
@@ -56,6 +57,7 @@ const termsCommand = defineCommand({
 		...connectionArgs,
 	},
 	async run({ args }) {
+		configureOutputMode(args);
 		try {
 			const client = createClientFromArgs(args);
 			const result = await client.terms(args.name, {
@@ -97,6 +99,7 @@ const addTermCommand = defineCommand({
 		...connectionArgs,
 	},
 	async run({ args }) {
+		configureOutputMode(args);
 		try {
 			const client = createClientFromArgs(args);
 			const label = args.name;

package/src/cli/output.ts

@@ -4,6 +4,20 @@ interface OutputArgs {
 	json?: boolean;
 }
 
+/**
+ * Redirect consola output to stderr so it doesn't pollute JSON on stdout.
+ *
+ * Call this early in any command that uses `output()` with `--json`.
+ * Safe to call multiple times — only applies the redirect once.
+ */
+export function configureOutputMode(args: OutputArgs): void {
+	if (args.json || !process.stdout.isTTY) {
+		// Send all consola output to stderr so stdout is clean JSON
+		consola.options.stdout = process.stderr;
+		consola.options.stderr = process.stderr;
+	}
+}
+
 /**
  * Output data as JSON or pretty-printed.
  *

package/src/components/InlinePortableTextEditor.tsx

@@ -25,6 +25,8 @@ import Suggestion from "@tiptap/suggestion";
 import * as React from "react";
 import { createPortal } from "react-dom";
 
+import { computeThumbnailSize } from "../media/thumbnail.js";
+
 // ── Portable Text types ────────────────────────────────────────────
 
 interface PTSpan {
@@ -1112,13 +1114,40 @@ function InlineMediaPicker({
 	const handleUpload = async (file: File) => {
 		setUploading(true);
 		try {
-			// Detect dimensions
-			const dims = await new Promise<{ width?: number; height?: number }>((resolve) => {
+			// Detect dimensions and generate a thumbnail for large images to
+			// avoid OOM in server-side blurhash generation on Workers.
+			const dims = await new Promise<{
+				width?: number;
+				height?: number;
+				thumbnail?: Blob;
+			}>((resolve) => {
 				if (!file.type.startsWith("image/")) return resolve({});
 				const img = new window.Image();
 				img.onload = () => {
-					resolve({ width: img.naturalWidth, height: img.naturalHeight });
+					const w = img.naturalWidth;
+					const h = img.naturalHeight;
+					// 32 MB RGBA threshold — matches server MAX_DECODED_BYTES
+					if (w * h * 4 > 32 * 1024 * 1024) {
+						const { width: thumbW, height: thumbH } = computeThumbnailSize(w, h);
+						try {
+							const canvas = document.createElement("canvas");
+							canvas.width = thumbW;
+							canvas.height = thumbH;
+							const ctx = canvas.getContext("2d");
+							if (ctx) {
+								ctx.drawImage(img, 0, 0, thumbW, thumbH);
+								canvas.toBlob((blob) => {
+									URL.revokeObjectURL(img.src);
+									resolve({ width: w, height: h, thumbnail: blob ?? undefined });
+								}, "image/png");
+								return;
+							}
+						} catch {
+							// Canvas allocation or draw failed — fall through to no-thumbnail path
+						}
+					}
 					URL.revokeObjectURL(img.src);
+					resolve({ width: w, height: h });
 				};
 				img.onerror = () => {
 					resolve({});
@@ -1134,6 +1163,7 @@ function InlineMediaPicker({
 				formData.append("file", file);
 				if (dims.width) formData.append("width", String(dims.width));
 				if (dims.height) formData.append("height", String(dims.height));
+				if (dims.thumbnail) formData.append("thumbnail", dims.thumbnail, "thumb.png");
 				const res = await ecFetch(`${API_BASE}/media`, { method: "POST", body: formData });
 				const data = await res.json();
 				const unwrapped = data.data ?? data;

package/src/database/migrations/033_optimize_content_indexes.ts

@@ -0,0 +1,113 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { listTablesLike } from "../dialect-helpers.js";
+
+/**
+ * Migration: Optimize content table indexes for D1 performance
+ *
+ * Addresses GitHub issue #131: Full table scans causing massive D1 row reads.
+ *
+ * Changes:
+ * 1. Replaces single-column indexes with composite indexes on ec_* tables
+ * 2. Adds partial indexes for _emdash_comments status counting
+ *
+ * Impact: Reduces D1 row reads by 90%+ for admin panel operations.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	const tableNames = await listTablesLike(db, "ec_%");
+
+	for (const tableName of tableNames) {
+		const table = { name: tableName };
+
+		// Drop redundant single-column indexes that will be replaced by composites
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${table.name}_status`)}`.execute(db);
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${table.name}_created`)}`.execute(db);
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${table.name}_deleted`)}`.execute(db);
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${table.name}_updated`)}`.execute(db);
+
+		// Composite index for listing queries: WHERE deleted_at IS NULL ORDER BY updated_at DESC
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${table.name}_deleted_updated_id`)}
+			ON ${sql.ref(table.name)} (deleted_at, updated_at DESC, id DESC)
+		`.execute(db);
+
+		// Composite index for count-by-status queries: WHERE deleted_at IS NULL AND status = ?
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${table.name}_deleted_status`)}
+			ON ${sql.ref(table.name)} (deleted_at, status)
+		`.execute(db);
+
+		// Composite index for created-at ordering: WHERE deleted_at IS NULL ORDER BY created_at DESC
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${table.name}_deleted_created_id`)}
+			ON ${sql.ref(table.name)} (deleted_at, created_at DESC, id DESC)
+		`.execute(db);
+	}
+
+	// Add partial indexes for efficient comment status counting
+	// Each index contains only rows for one status, enabling fast COUNT queries
+	await sql`
+		CREATE INDEX IF NOT EXISTS idx_comments_pending
+		ON _emdash_comments (id)
+		WHERE status = 'pending'
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX IF NOT EXISTS idx_comments_approved
+		ON _emdash_comments (id)
+		WHERE status = 'approved'
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX IF NOT EXISTS idx_comments_spam
+		ON _emdash_comments (id)
+		WHERE status = 'spam'
+	`.execute(db);
+
+	await sql`
+		CREATE INDEX IF NOT EXISTS idx_comments_trash
+		ON _emdash_comments (id)
+		WHERE status = 'trash'
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	const tableNames = await listTablesLike(db, "ec_%");
+
+	for (const tableName of tableNames) {
+		const table = { name: tableName };
+
+		// Drop composite indexes
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${table.name}_deleted_updated_id`)}`.execute(db);
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${table.name}_deleted_status`)}`.execute(db);
+		await sql`DROP INDEX IF EXISTS ${sql.ref(`idx_${table.name}_deleted_created_id`)}`.execute(db);
+
+		// Restore original single-column indexes
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${table.name}_status`)}
+			ON ${sql.ref(table.name)} (status)
+		`.execute(db);
+
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${table.name}_created`)}
+			ON ${sql.ref(table.name)} (created_at)
+		`.execute(db);
+
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${table.name}_deleted`)}
+			ON ${sql.ref(table.name)} (deleted_at)
+		`.execute(db);
+
+		await sql`
+			CREATE INDEX ${sql.ref(`idx_${table.name}_updated`)}
+			ON ${sql.ref(table.name)} (updated_at)
+		`.execute(db);
+	}
+
+	// Drop partial indexes for comments
+	await sql`DROP INDEX IF EXISTS idx_comments_pending`.execute(db);
+	await sql`DROP INDEX IF EXISTS idx_comments_approved`.execute(db);
+	await sql`DROP INDEX IF EXISTS idx_comments_spam`.execute(db);
+	await sql`DROP INDEX IF EXISTS idx_comments_trash`.execute(db);
+}

package/src/database/migrations/runner.ts

@@ -33,6 +33,45 @@ import * as m029 from "./029_redirects.js";
 import * as m030 from "./030_widen_scheduled_index.js";
 import * as m031 from "./031_bylines.js";
 import * as m032 from "./032_rate_limits.js";
+import * as m033 from "./033_optimize_content_indexes.js";
+
+const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
+	"001_initial": m001,
+	"002_media_status": m002,
+	"003_schema_registry": m003,
+	"004_plugins": m004,
+	"005_menus": m005,
+	"006_taxonomy_defs": m006,
+	"007_widgets": m007,
+	"008_auth": m008,
+	"009_user_disabled": m009,
+	"011_sections": m011,
+	"012_search": m012,
+	"013_scheduled_publishing": m013,
+	"014_draft_revisions": m014,
+	"015_indexes": m015,
+	"016_api_tokens": m016,
+	"017_authorization_codes": m017,
+	"018_seo": m018,
+	"019_i18n": m019,
+	"020_collection_url_pattern": m020,
+	"021_remove_section_categories": m021,
+	"022_marketplace_plugin_state": m022,
+	"023_plugin_metadata": m023,
+	"024_media_placeholders": m024,
+	"025_oauth_clients": m025,
+	"026_cron_tasks": m026,
+	"027_comments": m027,
+	"028_drop_author_url": m028,
+	"029_redirects": m029,
+	"030_widen_scheduled_index": m030,
+	"031_bylines": m031,
+	"032_rate_limits": m032,
+	"033_optimize_content_indexes": m033,
+});
+
+/** Total number of registered migrations. Exported for use in tests. */
+export const MIGRATION_COUNT = Object.keys(MIGRATIONS).length;
 
 /**
  * Migration provider that uses statically imported migrations.
@@ -40,39 +79,7 @@ import * as m032 from "./032_rate_limits.js";
  */
 class StaticMigrationProvider implements MigrationProvider {
 	async getMigrations(): Promise<Record<string, Migration>> {
-		return {
-			"001_initial": m001,
-			"002_media_status": m002,
-			"003_schema_registry": m003,
-			"004_plugins": m004,
-			"005_menus": m005,
-			"006_taxonomy_defs": m006,
-			"007_widgets": m007,
-			"008_auth": m008,
-			"009_user_disabled": m009,
-			"011_sections": m011,
-			"012_search": m012,
-			"013_scheduled_publishing": m013,
-			"014_draft_revisions": m014,
-			"015_indexes": m015,
-			"016_api_tokens": m016,
-			"017_authorization_codes": m017,
-			"018_seo": m018,
-			"019_i18n": m019,
-			"020_collection_url_pattern": m020,
-			"021_remove_section_categories": m021,
-			"022_marketplace_plugin_state": m022,
-			"023_plugin_metadata": m023,
-			"024_media_placeholders": m024,
-			"025_oauth_clients": m025,
-			"026_cron_tasks": m026,
-			"027_comments": m027,
-			"028_drop_author_url": m028,
-			"029_redirects": m029,
-			"030_widen_scheduled_index": m030,
-			"031_bylines": m031,
-			"032_rate_limits": m032,
-		};
+		return MIGRATIONS;
 	}
 }
 

package/src/database/repositories/comment.ts

@@ -324,30 +324,42 @@ export class CommentRepository {
 
 	/**
 	 * Count comments grouped by status (for inbox badges)
+	 *
+	 * Uses four parallel COUNT queries with WHERE filters to leverage partial indexes
+	 * (idx_comments_pending, idx_comments_approved, idx_comments_spam, idx_comments_trash)
+	 * instead of a full table GROUP BY scan.
 	 */
 	async countByStatus(): Promise<Record<CommentStatus, number>> {
-		const rows = await this.db
-			.selectFrom("_emdash_comments")
-			.select(["status"])
-			.select((eb) => eb.fn.count("id").as("count"))
-			.groupBy("status")
-			.execute();
+		// Execute four parallel COUNT queries, each using its partial index
+		const [pending, approved, spam, trash] = await Promise.all([
+			this.db
+				.selectFrom("_emdash_comments")
+				.select((eb) => eb.fn.count("id").as("count"))
+				.where("status", "=", "pending")
+				.executeTakeFirst(),
+			this.db
+				.selectFrom("_emdash_comments")
+				.select((eb) => eb.fn.count("id").as("count"))
+				.where("status", "=", "approved")
+				.executeTakeFirst(),
+			this.db
+				.selectFrom("_emdash_comments")
+				.select((eb) => eb.fn.count("id").as("count"))
+				.where("status", "=", "spam")
+				.executeTakeFirst(),
+			this.db
+				.selectFrom("_emdash_comments")
+				.select((eb) => eb.fn.count("id").as("count"))
+				.where("status", "=", "trash")
+				.executeTakeFirst(),
+		]);
 
-		const counts: Record<CommentStatus, number> = {
-			pending: 0,
-			approved: 0,
-			spam: 0,
-			trash: 0,
+		return {
+			pending: Number(pending?.count ?? 0),
+			approved: Number(approved?.count ?? 0),
+			spam: Number(spam?.count ?? 0),
+			trash: Number(trash?.count ?? 0),
 		};
-
-		for (const row of rows) {
-			const status = row.status as CommentStatus;
-			if (status in counts) {
-				counts[status] = Number(row.count);
-			}
-		}
-
-		return counts;
 	}
 
 	/**

package/src/emdash-runtime.ts

@@ -160,6 +160,7 @@ const FIELD_TYPE_TO_KIND: Record<FieldType, string> = {
 	file: "file",
 	reference: "reference",
 	json: "json",
+	repeater: "repeater",
 };
 
 /**
@@ -1171,6 +1172,10 @@ export class EmDashRuntime {
 								label: v.charAt(0).toUpperCase() + v.slice(1),
 							}));
 						}
+						// Include full validation for repeater fields (subFields, minItems, maxItems)
+						if (field.type === "repeater" && field.validation) {
+							(entry as Record<string, unknown>).validation = field.validation;
+						}
 						fields[field.slug] = entry;
 					}
 				}
@@ -1180,6 +1185,7 @@ export class EmDashRuntime {
 					labelSingular: collection.labelSingular || collection.label,
 					supports: collection.supports || [],
 					hasSeo: collection.hasSeo,
+					urlPattern: collection.urlPattern,
 					fields,
 				};
 			}
@@ -1601,11 +1607,25 @@ export class EmDashRuntime {
 	// =========================================================================
 
 	async handleContentPublish(collection: string, id: string) {
-		return handleContentPublish(this.db, collection, id);
+		const result = await handleContentPublish(this.db, collection, id);
+
+		// Run afterPublish hooks (fire-and-forget)
+		if (result.success && result.data) {
+			this.runAfterPublishHooks(contentItemToRecord(result.data.item), collection);
+		}
+
+		return result;
 	}
 
 	async handleContentUnpublish(collection: string, id: string) {
-		return handleContentUnpublish(this.db, collection, id);
+		const result = await handleContentUnpublish(this.db, collection, id);
+
+		// Run afterUnpublish hooks (fire-and-forget)
+		if (result.success && result.data) {
+			this.runAfterUnpublishHooks(contentItemToRecord(result.data.item), collection);
+		}
+
+		return result;
 	}
 
 	async handleContentSchedule(collection: string, id: string, scheduledAt: string) {
@@ -1964,6 +1984,48 @@ export class EmDashRuntime {
 		}
 	}
 
+	private runAfterPublishHooks(content: Record<string, unknown>, collection: string): void {
+		// Trusted plugins
+		if (this.hooks.hasHooks("content:afterPublish")) {
+			this.hooks
+				.runContentAfterPublish(content, collection)
+				.catch((err) => console.error("EmDash afterPublish hook error:", err));
+		}
+
+		// Sandboxed plugins
+		for (const [pluginKey, plugin] of this.sandboxedPlugins) {
+			const [pluginId] = pluginKey.split(":");
+			if (!pluginId || !this.isPluginEnabled(pluginId)) continue;
+
+			plugin
+				.invokeHook("content:afterPublish", { content, collection })
+				.catch((err) =>
+					console.error(`EmDash: Sandboxed plugin ${pluginId} afterPublish error:`, err),
+				);
+		}
+	}
+
+	private runAfterUnpublishHooks(content: Record<string, unknown>, collection: string): void {
+		// Trusted plugins
+		if (this.hooks.hasHooks("content:afterUnpublish")) {
+			this.hooks
+				.runContentAfterUnpublish(content, collection)
+				.catch((err) => console.error("EmDash afterUnpublish hook error:", err));
+		}
+
+		// Sandboxed plugins
+		for (const [pluginKey, plugin] of this.sandboxedPlugins) {
+			const [pluginId] = pluginKey.split(":");
+			if (!pluginId || !this.isPluginEnabled(pluginId)) continue;
+
+			plugin
+				.invokeHook("content:afterUnpublish", { content, collection })
+				.catch((err) =>
+					console.error(`EmDash: Sandboxed plugin ${pluginId} afterUnpublish error:`, err),
+				);
+		}
+	}
+
 	private async handleSandboxedRoute(
 		plugin: SandboxedPlugin,
 		path: string,

package/src/media/placeholder.ts

@@ -7,6 +7,7 @@
  */
 
 import { encode } from "blurhash";
+import { imageSize } from "image-size";
 
 export interface PlaceholderData {
 	blurhash: string;
@@ -22,6 +23,9 @@ const SUPPORTED_TYPES: Record<string, "jpeg" | "png"> = {
 /** Max width for blurhash input. Encode is O(w*h*components), so downsample first. */
 const MAX_ENCODE_WIDTH = 32;
 
+/** Max decoded RGBA size (32 MB). Images exceeding this skip placeholder generation. */
+const MAX_DECODED_BYTES = 32 * 1024 * 1024;
+
 interface DecodedImage {
 	width: number;
 	height: number;
@@ -79,18 +83,45 @@ function extractDominantColor(data: Uint8Array, width: number, height: number):
 	return `rgb(${avgR},${avgG},${avgB})`;
 }
 
+/**
+ * Read image dimensions from headers without decoding pixel data.
+ */
+function getImageDimensions(buffer: Uint8Array): { width: number; height: number } | null {
+	try {
+		const result = imageSize(buffer);
+		if (result.width != null && result.height != null) {
+			return { width: result.width, height: result.height };
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
 /**
  * Generate blurhash and dominant color from an image buffer.
  * Returns null for non-image MIME types or on failure.
+ *
+ * @param dimensions - Optional pre-known dimensions. Used as a fallback when
+ *   image-size cannot parse the buffer (e.g. truncated headers). When the
+ *   decoded size (width * height * 4) exceeds MAX_DECODED_BYTES, placeholder
+ *   generation is skipped to avoid OOM on memory-constrained runtimes.
  */
 export async function generatePlaceholder(
 	buffer: Uint8Array,
 	mimeType: string,
+	dimensions?: { width: number; height: number },
 ): Promise<PlaceholderData | null> {
 	const format = SUPPORTED_TYPES[mimeType];
 	if (!format) return null;
 
 	try {
+		// Safety net: skip decode if the image would exceed the memory budget
+		const dims = getImageDimensions(buffer) ?? dimensions;
+		if (dims && dims.width * dims.height * 4 > MAX_DECODED_BYTES) {
+			return null;
+		}
+
 		const imageData = format === "jpeg" ? await decodeJpeg(buffer) : await decodePng(buffer);
 		const { width, height, data } = imageData;
 

package/src/media/thumbnail.ts

@@ -0,0 +1,32 @@
+/**
+ * Thumbnail sizing for client-side placeholder generation.
+ *
+ * When the browser generates a thumbnail to send to the server for blurhash
+ * generation, the thumbnail dimensions must fit within a bounded box. Naively
+ * fixing one dimension and deriving the other from the aspect ratio can
+ * explode for extreme aspect ratios (e.g. a 100×840000 image would produce a
+ * 64×537600 canvas), defeating the purpose of the thumbnail.
+ */
+
+/** Max dimension (px) for client-generated upload thumbnails. */
+export const THUMBNAIL_MAX_DIMENSION = 64;
+
+/**
+ * Compute thumbnail dimensions that fit within a THUMBNAIL_MAX_DIMENSION box,
+ * preserving aspect ratio. Both output dimensions are clamped to at least 1.
+ * Never upscales (scale is capped at 1).
+ */
+export function computeThumbnailSize(
+	width: number,
+	height: number,
+): { width: number; height: number } {
+	if (width <= 0 || height <= 0) {
+		return { width: 1, height: 1 };
+	}
+	const maxDim = Math.max(width, height);
+	const scale = Math.min(1, THUMBNAIL_MAX_DIMENSION / maxDim);
+	return {
+		width: Math.max(1, Math.round(width * scale)),
+		height: Math.max(1, Math.round(height * scale)),
+	};
+}