emdash 0.24.0 → 0.25.1

package/src/components/Image.astro

@@ -25,7 +25,8 @@ export interface Props {
 			url?: string;
 			/** Provider ID for external media (e.g., "cloudflare-images") */
 			provider?: string;
-			/** Provider metadata (blurhash, dominantColor, etc.) */
+			/** Provider metadata. LQIP is read from first-class fields below;
+			 *  `meta` only remains as a fallback for legacy snapshots. */
 			meta?: Record<string, unknown>;
 		};
 		alt?: string;
@@ -34,6 +35,10 @@ export interface Props {
 		width?: number;
 		/** Original image height */
 		height?: number;
+		/** LQIP blurhash — first-class field (legacy snapshots store it in `asset.meta`). */
+		blurhash?: string;
+		/** LQIP dominant color — first-class field (legacy snapshots store it in `asset.meta`). */
+		dominantColor?: string;
 		/** Display width for this instance (overrides original) */
 		displayWidth?: number;
 		/** Display height for this instance (overrides original) */
@@ -152,9 +157,14 @@ if (!src) {
 	}
 }
 
-// Build placeholder background style
-const blurhash = asset.meta?.blurhash as string | undefined;
-const dominantColor = asset.meta?.dominantColor as string | undefined;
+// Build placeholder background style. Prefer first-class LQIP fields; fall
+// back to `asset.meta` for legacy snapshots persisted before LQIP was promoted.
+const blurhash = (node.blurhash ?? (asset.meta?.blurhash as string | undefined)) as
+	| string
+	| undefined;
+const dominantColor = (node.dominantColor ?? (asset.meta?.dominantColor as string | undefined)) as
+	| string
+	| undefined;
 
 let placeholderStyle = "";
 if (blurhash) {

package/src/components/InlinePortableTextEditor.tsx

@@ -200,6 +200,13 @@ function convertPMNode(node: PMNode): PTBlock | PTBlock[] | null {
 		}
 		case "image": {
 			const provider = attrStrOpt(node.attrs, "provider");
+			const blurhash = attrStrOpt(node.attrs, "blurhash");
+			const dominantColor = attrStrOpt(node.attrs, "dominantColor");
+			// Persist LQIP as first-class block fields (matching the image-field
+			// MediaValue path) rather than nesting in `asset.meta`, so read sites
+			// and normalize don't need a dual-shape fallback. `asset.meta` is left
+			// to carry only provider-specific data — it isn't reconstructed here,
+			// so non-LQIP meta keys are never silently dropped on editor round-trip.
 			return {
 				_type: "image",
 				_key: k(),
@@ -212,6 +219,8 @@ function convertPMNode(node: PMNode): PTBlock | PTBlock[] | null {
 				caption: attrStrOpt(node.attrs, "caption") ?? attrStrOpt(node.attrs, "title"),
 				width: attrNum(node.attrs, "width"),
 				height: attrNum(node.attrs, "height"),
+				...(blurhash ? { blurhash } : {}),
+				...(dominantColor ? { dominantColor } : {}),
 				displayWidth: attrNum(node.attrs, "displayWidth"),
 				displayHeight: attrNum(node.attrs, "displayHeight"),
 			};
@@ -416,16 +425,38 @@ function convertPTBlock(block: PTBlock): JSONContent | null {
 	}
 	if (block._type === "image") {
 		const ib = block as PTBlock & {
-			asset?: { _ref?: string; url?: string; provider?: string };
+			asset?: {
+				_ref?: string;
+				url?: string;
+				provider?: string;
+				meta?: Record<string, unknown>;
+			};
 			url?: string;
 			alt?: string;
 			caption?: string;
 			width?: number;
 			height?: number;
+			/** LQIP — first-class field (legacy snapshots keep it in `asset.meta`). */
+			blurhash?: string;
+			dominantColor?: string;
 			displayWidth?: number;
 			displayHeight?: number;
 		};
 		const asset = ib.asset;
+		const meta = asset?.meta;
+		// Prefer first-class LQIP fields; fall back to `asset.meta` for legacy.
+		const blurhash =
+			typeof ib.blurhash === "string"
+				? ib.blurhash
+				: typeof meta?.blurhash === "string"
+					? meta.blurhash
+					: null;
+		const dominantColor =
+			typeof ib.dominantColor === "string"
+				? ib.dominantColor
+				: typeof meta?.dominantColor === "string"
+					? meta.dominantColor
+					: null;
 		return {
 			type: "image",
 			attrs: {
@@ -437,6 +468,8 @@ function convertPTBlock(block: PTBlock): JSONContent | null {
 				provider: asset?.provider,
 				width: ib.width,
 				height: ib.height,
+				blurhash,
+				dominantColor,
 				displayWidth: ib.displayWidth,
 				displayHeight: ib.displayHeight,
 			},
@@ -1145,6 +1178,8 @@ interface MediaItemData {
 	storageKey?: string;
 	width?: number;
 	height?: number;
+	blurhash?: string;
+	dominantColor?: string;
 	alt?: string;
 	provider?: string;
 	previewUrl?: string;
@@ -1224,6 +1259,8 @@ function InlineMediaPicker({
 					storageKey?: string;
 					width?: number;
 					height?: number;
+					blurhash?: string;
+					dominantColor?: string;
 					alt?: string;
 					meta?: Record<string, unknown>;
 				}>;
@@ -1239,6 +1276,8 @@ function InlineMediaPicker({
 						storageKey: item.storageKey,
 						width: item.width,
 						height: item.height,
+						blurhash: item.blurhash,
+						dominantColor: item.dominantColor,
 						alt: item.alt,
 						provider: activeProvider === "local" ? undefined : activeProvider,
 						previewUrl: item.previewUrl,
@@ -1319,6 +1358,8 @@ function InlineMediaPicker({
 					storageKey: raw.storageKey,
 					width: raw.width || dims.width,
 					height: raw.height || dims.height,
+					blurhash: raw.blurhash,
+					dominantColor: raw.dominantColor,
 					alt: raw.alt,
 				};
 			} else {
@@ -1339,6 +1380,8 @@ function InlineMediaPicker({
 					url: raw.previewUrl || "",
 					width: raw.width || dims.width,
 					height: raw.height || dims.height,
+					blurhash: raw.blurhash,
+					dominantColor: raw.dominantColor,
 					alt: raw.alt,
 					provider: activeProvider,
 					previewUrl: raw.previewUrl,
@@ -1854,6 +1897,8 @@ export function InlinePortableTextEditor({
 						provider: { default: null },
 						width: { default: null },
 						height: { default: null },
+						blurhash: { default: null },
+						dominantColor: { default: null },
 					};
 				},
 			}),
@@ -1924,6 +1969,8 @@ export function InlinePortableTextEditor({
 					mediaId: item.id,
 					width: item.width,
 					height: item.height,
+					blurhash: item.blurhash,
+					dominantColor: item.dominantColor,
 				})
 				.run();
 			setMediaPickerOpen(false);

package/src/database/repositories/content.ts

@@ -656,19 +656,22 @@ export class ContentRepository {
 	/**
 	 * Restore content from trash
 	 */
-	async restore(type: string, id: string): Promise<boolean> {
+	async restore(type: string, id: string): Promise<ContentItem | null> {
 		const tableName = getTableName(type);
 
-		const result = await sql`
+		const result = await sql<Record<string, unknown>>`
 			UPDATE ${sql.ref(tableName)}
 			SET deleted_at = NULL
 			WHERE id = ${id}
 			AND deleted_at IS NOT NULL
+			RETURNING *
 		`.execute(this.db);
 
-		const changed = (result.numAffectedRows ?? 0n) > 0n;
-		if (changed) invalidateCollectionCache(type);
-		return changed;
+		const restored = result.rows[0];
+		if (!restored) return null;
+
+		invalidateCollectionCache(type);
+		return this.mapRow(type, restored);
 	}
 
 	/**

package/src/database/repositories/media.ts

@@ -143,7 +143,13 @@ export class MediaRepository {
 	 */
 	async confirmUpload(
 		id: string,
-		metadata?: { width?: number; height?: number; size?: number },
+		metadata?: {
+			width?: number;
+			height?: number;
+			size?: number;
+			blurhash?: string;
+			dominantColor?: string;
+		},
 	): Promise<MediaItem | null> {
 		const existing = await this.findById(id);
 		if (!existing) {
@@ -156,6 +162,8 @@ export class MediaRepository {
 		if (metadata?.width !== undefined) updates.width = metadata.width;
 		if (metadata?.height !== undefined) updates.height = metadata.height;
 		if (metadata?.size !== undefined) updates.size = metadata.size;
+		if (metadata?.blurhash !== undefined) updates.blurhash = metadata.blurhash;
+		if (metadata?.dominantColor !== undefined) updates.dominant_color = metadata.dominantColor;
 
 		await this.db.updateTable("media").set(updates).where("id", "=", id).execute();
 

package/src/emdash-runtime.ts

@@ -2797,7 +2797,14 @@ export class EmDashRuntime {
 	}
 
 	async handleContentRestore(collection: string, id: string) {
-		return handleContentRestore(this.db, collection, id);
+		const result = await handleContentRestore(this.db, collection, id);
+
+		// Run afterRestore hooks (fire-and-forget)
+		if (result.success) {
+			this.runAfterRestoreHooks(contentItemToRecord(result.data.item), collection);
+		}
+
+		return result;
 	}
 
 	async handleContentPermanentDelete(collection: string, id: string) {
@@ -3365,6 +3372,37 @@ export class EmDashRuntime {
 		}
 	}
 
+	private runAfterRestoreHooks(content: Record<string, unknown>, collection: string): void {
+		after(async () => {
+			// Trusted plugins
+			if (this.hooks.hasHooks("content:afterRestore")) {
+				try {
+					await this.hooks.runContentAfterRestore(content, collection);
+				} catch (err) {
+					console.error("EmDash afterRestore hook error:", err);
+				}
+			}
+
+			// Sandboxed plugins
+			const tasks: Promise<void>[] = [];
+			for (const [pluginKey, plugin] of this.sandboxedPlugins) {
+				const [pluginId] = pluginKey.split(":");
+				if (!pluginId || !this.isPluginEnabled(pluginId)) continue;
+
+				tasks.push(
+					(async () => {
+						try {
+							await plugin.invokeHook("content:afterRestore", { content, collection });
+						} catch (err) {
+							console.error(`EmDash: Sandboxed plugin ${pluginId} afterRestore error:`, err);
+						}
+					})(),
+				);
+			}
+			await Promise.allSettled(tasks);
+		});
+	}
+
 	private async handleSandboxedRoute(
 		plugin: SandboxedPluginInstance,
 		path: string,

package/src/media/enrich.ts

@@ -0,0 +1,78 @@
+/**
+ * Image Metadata Enrichment
+ *
+ * Single seam that derives image dimensions and LQIP placeholders (blurhash,
+ * dominant color) from raw image bytes. Every server-side media-creation path
+ * routes through this so records are populated consistently. Pure-JS and
+ * Workers-safe (image-size reads headers only; generatePlaceholder guards
+ * decode size).
+ */
+
+import { normalizeMime } from "./mime.js";
+import { generatePlaceholder, readDimensions } from "./placeholder.js";
+
+export interface EnrichedImageMetadata {
+	width?: number;
+	height?: number;
+	blurhash?: string;
+	dominantColor?: string;
+}
+
+/**
+ * Derive dimensions + LQIP placeholders from image bytes.
+ *
+ * - Non-image content types return `{}`.
+ * - `knownDimensions` (e.g. browser `naturalWidth/Height`) win over `image-size`
+ *   for the *stored record* because the browser applies EXIF orientation;
+ *   `image-size` reports raw header dimensions, which are swapped for
+ *   90°/270°-rotated JPEGs. They are NOT used for the decode OOM guard — see below.
+ * - The placeholder OOM guard uses only header dimensions read from the bytes
+ *   actually decoded. Caller-supplied `knownDimensions` are untrusted for the
+ *   guard: a client could claim a tiny size for a huge image to bypass the cap.
+ * - `placeholder` lets a caller decode a smaller thumbnail for the blurhash to
+ *   avoid OOM on large originals; dimensions still come from `bytes`.
+ * - Placeholders are jpeg/png only (the generator's supported formats); other
+ *   image types still get dimensions.
+ */
+export async function enrichImageMetadata(
+	bytes: Uint8Array,
+	contentType: string,
+	opts?: {
+		knownDimensions?: { width: number; height: number };
+		placeholder?: { bytes: Uint8Array; contentType: string };
+	},
+): Promise<EnrichedImageMetadata> {
+	const normalizedContentType = normalizeMime(contentType);
+	if (!normalizedContentType.startsWith("image/")) return {};
+
+	// Header dimensions are read once from the actual bytes. They feed the
+	// placeholder OOM guard, which must never trust caller-supplied dimensions:
+	// `knownDimensions` is decoupled from the buffer, so a client could claim a
+	// tiny size for a huge image and slip past the decoded-size cap, making the
+	// decoder allocate an unbounded RGBA buffer and OOM the runtime. Only dims
+	// read from the buffer that actually gets decoded can bound the decode.
+	const headerDims = readDimensions(bytes) ?? undefined;
+
+	// Dimensions published on the record prefer the caller's knownDimensions
+	// (e.g. browser naturalWidth/Height, which apply EXIF orientation) over the
+	// raw header dims, which are swapped for 90°/270°-rotated JPEGs.
+	const recordDims = opts?.knownDimensions ?? headerDims;
+
+	// When a smaller thumbnail override is supplied, decode that for the blurhash
+	// and let generatePlaceholder read the thumbnail's own header for the OOM
+	// guard (the override buffer is what actually gets decoded). On the common
+	// no-override path pass the header dims already read from this same buffer.
+	const override = opts?.placeholder;
+	const placeholder = await generatePlaceholder(
+		override ? override.bytes : bytes,
+		override ? normalizeMime(override.contentType) : normalizedContentType,
+		override ? undefined : headerDims,
+	);
+
+	return {
+		width: recordDims?.width,
+		height: recordDims?.height,
+		blurhash: placeholder?.blurhash,
+		dominantColor: placeholder?.dominantColor,
+	};
+}

package/src/media/index.ts

@@ -27,6 +27,7 @@ export type {
 export { mediaItemToValue } from "./types.js";
 export { normalizeMediaValue } from "./normalize.js";
 export { generatePlaceholder, type PlaceholderData } from "./placeholder.js";
+export { enrichImageMetadata, type EnrichedImageMetadata } from "./enrich.js";
 
 // Built-in providers
 export { localMedia, type LocalMediaConfig } from "./local.js";

package/src/media/local-runtime.ts

@@ -73,6 +73,8 @@ export const createMediaProvider: CreateMediaProviderFn<LocalMediaRuntimeConfig>
 					size: item.size ?? undefined,
 					width: item.width ?? undefined,
 					height: item.height ?? undefined,
+					blurhash: item.blurhash ?? undefined,
+					dominantColor: item.dominantColor ?? undefined,
 					alt: item.alt ?? undefined,
 					previewUrl: `/_emdash/api/media/file/${item.storageKey}`,
 					meta: {
@@ -97,6 +99,8 @@ export const createMediaProvider: CreateMediaProviderFn<LocalMediaRuntimeConfig>
 				size: item.size ?? undefined,
 				width: item.width ?? undefined,
 				height: item.height ?? undefined,
+				blurhash: item.blurhash ?? undefined,
+				dominantColor: item.dominantColor ?? undefined,
 				alt: item.alt ?? undefined,
 				previewUrl: `/_emdash/api/media/file/${item.storageKey}`,
 				meta: {
@@ -148,6 +152,15 @@ export const createMediaProvider: CreateMediaProviderFn<LocalMediaRuntimeConfig>
 			const src = `/_emdash/api/media/file/${storageKey}`;
 			const mimeType = value.mimeType || "";
 
+			// Prefer the first-class fields; fall back to `meta` for legacy snapshots
+			// stored before LQIP was promoted off the provider-specific `meta` bag.
+			const blurhash =
+				value.blurhash ??
+				(typeof value.meta?.blurhash === "string" ? value.meta.blurhash : undefined);
+			const dominantColor =
+				value.dominantColor ??
+				(typeof value.meta?.dominantColor === "string" ? value.meta.dominantColor : undefined);
+
 			// Determine embed type based on MIME type
 			if (mimeType.startsWith("image/")) {
 				return {
@@ -155,6 +168,8 @@ export const createMediaProvider: CreateMediaProviderFn<LocalMediaRuntimeConfig>
 					src,
 					width: value.width,
 					height: value.height,
+					blurhash,
+					dominantColor,
 					alt: value.alt,
 				};
 			}
@@ -185,6 +200,8 @@ export const createMediaProvider: CreateMediaProviderFn<LocalMediaRuntimeConfig>
 				src,
 				width: value.width,
 				height: value.height,
+				blurhash,
+				dominantColor,
 				alt: value.alt,
 			};
 		},
@@ -221,6 +238,8 @@ export function repoItemToProviderItem(item: {
 		size: item.size ?? undefined,
 		width: item.width ?? undefined,
 		height: item.height ?? undefined,
+		blurhash: item.blurhash ?? undefined,
+		dominantColor: item.dominantColor ?? undefined,
 		alt: item.alt ?? undefined,
 		previewUrl: `/_emdash/api/media/file/${item.storageKey}`,
 		meta: {

package/src/media/normalize.ts

@@ -60,7 +60,14 @@ export async function normalizeMediaValue(
 	const needsDimensions = result.width == null || result.height == null;
 	const needsStorageKey = provider === "local" && !result.meta?.storageKey;
 	const needsFileInfo = !result.mimeType || !result.filename;
-	const needsLookup = needsDimensions || needsStorageKey || needsFileInfo;
+	// LQIP placeholders are immutable facts of the bytes: if an image record is
+	// missing them, the provider may have gained them since (e.g. content saved
+	// before LQIP backfill ran, or the row's blurhash was populated later). Pull
+	// them on every image lookup so the LQIP backfill in mergeProviderData runs.
+	const needsLqip =
+		(result.mimeType ?? "").startsWith("image/") &&
+		(result.blurhash == null || result.dominantColor == null);
+	const needsLookup = needsDimensions || needsStorageKey || needsFileInfo || needsLqip;
 
 	if (!needsLookup || !id) return result;
 
@@ -138,6 +145,8 @@ async function resolveInternalUrl(
 		mimeType: item.mimeType,
 		width: item.width,
 		height: item.height,
+		blurhash: item.blurhash,
+		dominantColor: item.dominantColor,
 		alt: item.alt,
 		meta: item.meta,
 	};
@@ -167,6 +176,8 @@ async function resolveLocalId(
 		mimeType: item.mimeType,
 		width: item.width,
 		height: item.height,
+		blurhash: item.blurhash,
+		dominantColor: item.dominantColor,
 		alt: item.alt,
 		meta: item.meta,
 	};
@@ -183,6 +194,12 @@ function mergeProviderData(existing: MediaValue, item: MediaProviderItem): Media
 	if (result.width == null && item.width != null) result.width = item.width;
 	if (result.height == null && item.height != null) result.height = item.height;
 
+	// Fill missing LQIP placeholders (immutable facts of the bytes; caller wins)
+	if (result.blurhash == null && item.blurhash != null) result.blurhash = item.blurhash;
+	if (result.dominantColor == null && item.dominantColor != null) {
+		result.dominantColor = item.dominantColor;
+	}
+
 	// Fill missing file info
 	if (!result.filename && item.filename) result.filename = item.filename;
 	if (!result.mimeType && item.mimeType) result.mimeType = item.mimeType;
@@ -217,6 +234,8 @@ function recordToMediaValue(obj: Record<string, unknown>): MediaValue {
 	if (typeof obj.mimeType === "string") result.mimeType = obj.mimeType;
 	if (typeof obj.width === "number") result.width = obj.width;
 	if (typeof obj.height === "number") result.height = obj.height;
+	if (typeof obj.blurhash === "string") result.blurhash = obj.blurhash;
+	if (typeof obj.dominantColor === "string") result.dominantColor = obj.dominantColor;
 	if (typeof obj.alt === "string") result.alt = obj.alt;
 	if (isRecord(obj.meta)) result.meta = obj.meta;
 	return result;

package/src/media/placeholder.ts

@@ -9,6 +9,8 @@
 import { encode } from "blurhash";
 import { imageSize } from "image-size";
 
+import { normalizeMime } from "./mime.js";
+
 export interface PlaceholderData {
 	blurhash: string;
 	dominantColor: string;
@@ -85,8 +87,12 @@ function extractDominantColor(data: Uint8Array, width: number, height: number):
 
 /**
  * Read image dimensions from headers without decoding pixel data.
+ * Returns null when the header cannot be parsed.
+ *
+ * Shared by every caller that needs pixel dimensions so the header is parsed
+ * once per buffer, not re-read inside generatePlaceholder.
  */
-function getImageDimensions(buffer: Uint8Array): { width: number; height: number } | null {
+export function readDimensions(buffer: Uint8Array): { width: number; height: number } | null {
 	try {
 		const result = imageSize(buffer);
 		if (result.width != null && result.height != null) {
@@ -102,23 +108,37 @@ function getImageDimensions(buffer: Uint8Array): { width: number; height: number
  * 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.
+ * @param dimensions - Optional pre-known dimensions. When present they are
+ *   trusted verbatim (the caller has typically already read them via
+ *   readDimensions); otherwise dimensions are read from this buffer's header.
+ *   Generation is skipped (returns null) when no dimensions are available at
+ *   all, or when the decoded size (width * height * 4) exceeds
+ *   MAX_DECODED_BYTES — both guards avoid OOM from unbounded decodes 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];
+	const format = SUPPORTED_TYPES[normalizeMime(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) {
+		// Trust caller-supplied dimensions when present (the caller has usually
+		// already read them via readDimensions); otherwise read them from this
+		// buffer. The header is parsed at most once per call.
+		const dims = dimensions ?? readDimensions(buffer);
+
+		// Safety net: the decoders allocate the full RGBA buffer with no internal
+		// cap, so refuse to decode unless we can bound the output size. When we
+		// have no parseable header AND no known dimensions, the decoded size is
+		// unbounded — a crafted/truncated PNG whose header image-size can't read
+		// could still be decodable by upng-js, so we must bail to avoid OOM on
+		// memory-constrained runtimes. LQIP is progressive enhancement; missing
+		// it is preferable to crashing the request.
+		if (!dims) return null;
+		if (dims.width * dims.height * 4 > MAX_DECODED_BYTES) {
 			return null;
 		}
 

package/src/media/types.ts

@@ -85,6 +85,10 @@ export interface MediaProviderItem {
 	/** Dimensions (for images/video) */
 	width?: number;
 	height?: number;
+	/** LQIP blurhash placeholder (images only) */
+	blurhash?: string;
+	/** LQIP dominant-color placeholder, as a CSS color (images only) */
+	dominantColor?: string;
 	/** Accessibility text */
 	alt?: string;
 	/** Preview URL for admin UI thumbnail */
@@ -126,6 +130,10 @@ export interface ImageEmbed {
 	sizes?: string;
 	width?: number;
 	height?: number;
+	/** LQIP blurhash placeholder for rendering before the image loads */
+	blurhash?: string;
+	/** LQIP dominant-color placeholder, as a CSS color */
+	dominantColor?: string;
 	alt?: string;
 	/** Base URL without transforms, for responsive image generation */
 	cdnBaseUrl?: string;
@@ -256,6 +264,10 @@ export interface MediaValue {
 	mimeType?: string;
 	width?: number;
 	height?: number;
+	/** Cached LQIP blurhash placeholder (images only) */
+	blurhash?: string;
+	/** Cached LQIP dominant-color placeholder, as a CSS color (images only) */
+	dominantColor?: string;
 	alt?: string;
 
 	/** Provider-specific data needed for embedding */
@@ -273,6 +285,8 @@ export function mediaItemToValue(providerId: string, item: MediaProviderItem): M
 		mimeType: item.mimeType,
 		width: item.width,
 		height: item.height,
+		blurhash: item.blurhash,
+		dominantColor: item.dominantColor,
 		alt: item.alt,
 		meta: item.meta,
 	};

package/src/plugin-types.ts

@@ -49,6 +49,7 @@ import type {
 	CommentModerateHandler,
 	ContentAfterDeleteHandler,
 	ContentAfterPublishHandler,
+	ContentAfterRestoreHandler,
 	ContentAfterSaveHandler,
 	ContentAfterUnpublishHandler,
 	ContentBeforeDeleteHandler,
@@ -97,6 +98,7 @@ export interface HookHandlers {
 	"content:afterDelete": ContentAfterDeleteHandler;
 	"content:afterPublish": ContentAfterPublishHandler;
 	"content:afterUnpublish": ContentAfterUnpublishHandler;
+	"content:afterRestore": ContentAfterRestoreHandler;
 	"media:beforeUpload": MediaBeforeUploadHandler;
 	"media:afterUpload": MediaAfterUploadHandler;
 	cron: CronHandler;

package/src/plugins/context.ts

@@ -21,6 +21,7 @@ import {
 	SsrfError,
 	stripCredentialHeaders,
 } from "../import/ssrf.js";
+import { enrichImageMetadata } from "../media/enrich.js";
 import { invalidateSiteSettingsCache } from "../settings/index.js";
 import type { Storage } from "../storage/types.js";
 import { CronAccessImpl } from "./cron.js";
@@ -508,6 +509,9 @@ export function createMediaAccessWithWrite(
 				contentType,
 			});
 
+			// Derive dimensions + LQIP placeholders (no-op for non-images).
+			const enriched = await enrichImageMetadata(new Uint8Array(bytes), contentType);
+
 			// Create DB record — clean up storage on failure
 			let media;
 			try {
@@ -517,6 +521,10 @@ export function createMediaAccessWithWrite(
 					size: bytes.byteLength,
 					storageKey,
 					status: "ready",
+					width: enriched.width,
+					height: enriched.height,
+					blurhash: enriched.blurhash,
+					dominantColor: enriched.dominantColor,
 				});
 			} catch (error) {
 				try {