emdash 0.30.0 → 0.31.1

package/src/components/Gallery.astro

@@ -2,11 +2,17 @@
 /**
  * Portable Text Gallery block component
  *
- * Renders image galleries from WordPress imports.
- * Uses Astro's Image component for optimization when dimensions are available.
+ * Renders image galleries from WordPress imports and EmDash media.
+ * Uses the provider's getEmbed/getSrc functions for external media (mirrors
+ * Image.astro), falling back to Astro's Image component when dimensions are
+ * available for locally-stored media.
  */
 import { Image as AstroImage } from "astro:assets";
+import type { ImageEmbed } from "../media/types.js";
+import { getMediaProvider } from "../media/provider-loader.js";
 import { buildRenderMediaUrl } from "../media/url.js";
+import { toAbsoluteMediaUrl, RESPONSIVE_BREAKPOINTS } from "../media/responsive.js";
+import { getPublicOrigin } from "../api/public-url.js";
 
 export interface Props {
 	node: {
@@ -18,50 +24,159 @@ export interface Props {
 			asset: {
 				_ref: string;
 				url?: string;
+				/** Provider ID for external media (e.g., "cloudflare-images") */
+				provider?: string;
 			};
 			alt?: string;
 			caption?: string;
 			width?: number;
 			height?: number;
+			/** LQIP blurhash placeholder (images only) */
+			blurhash?: string;
+			/** LQIP dominant-color placeholder, as a CSS color (images only) */
+			dominantColor?: string;
 		}>;
 		columns?: number;
 	};
+	/** Render the LQIP placeholder as an inline background. Disable for strict CSP. */
+	placeholder?: boolean;
 }
 
-const { node } = Astro.props;
+/**
+ * Generate srcset using provider's getSrc function
+ */
+function generateSrcset(
+	getSrc: NonNullable<ImageEmbed["getSrc"]>,
+	maxWidth: number,
+	aspectRatio?: number,
+): string {
+	return RESPONSIVE_BREAKPOINTS.filter((w) => w <= maxWidth * 2)
+		.map((w) => {
+			const h = aspectRatio ? Math.round(w / aspectRatio) : undefined;
+			return `${getSrc({ width: w, height: h })} ${w}w`;
+		})
+		.join(", ");
+}
+
+const { node, placeholder = true } = Astro.props;
 const images = node?.images ?? [];
 const columns = node?.columns ?? 3;
 
 if (!images.length) {
 	return null;
 }
+
+// Resolve provider embeds up front (async), keeping the template's `.map()`
+// synchronous over the resolved data — mirrors Image.astro's per-image logic.
+const resolvedImages = await Promise.all(
+	images.map(async (image) => {
+		const { asset, alt = "", width, height } = image;
+		const aspectRatio = width && height ? width / height : undefined;
+
+		let src = "";
+		let srcset: string | undefined;
+		let sizes: string | undefined;
+		let astroImageSrc = "";
+		const providerId = asset.provider;
+
+		if (providerId && providerId !== "local") {
+			const provider = await getMediaProvider(providerId);
+			if (provider) {
+				try {
+					const mediaValue = {
+						provider: providerId,
+						id: asset._ref,
+						width,
+						height,
+						alt,
+					};
+					const result = provider.getEmbed(mediaValue, { width, height });
+					const embed = result instanceof Promise ? await result : result;
+					if (embed.type === "image") {
+						src = embed.src;
+
+						if (embed.getSrc) {
+							const maxWidth = width || 1200;
+							srcset = generateSrcset(embed.getSrc, maxWidth, aspectRatio);
+							sizes = width ? `(min-width: ${width}px) ${width}px, 100vw` : "100vw";
+						}
+					}
+				} catch (error) {
+					console.warn(`Failed to get embed for image ${asset._ref}:`, error);
+				}
+			}
+		}
+
+		// Fallback for local provider. `asset.url` carries the storage key with
+		// extension when present; `asset._ref` is a bare ULID that only the
+		// internal `/file/{id}` route can resolve. `buildRenderMediaUrl` picks
+		// the right shape.
+		if (!src) {
+			src = buildRenderMediaUrl(Astro.locals.emdash?.getPublicMediaUrl, {
+				url: asset.url,
+				id: asset._ref,
+			});
+			if (width && height) {
+				astroImageSrc = toAbsoluteMediaUrl(
+					src,
+					getPublicOrigin(Astro.url, Astro.locals.emdash?.config),
+				);
+			}
+		}
+
+		// Prefer blurhash over dominant color for the LQIP placeholder, like
+		// Image.astro.
+		let placeholderStyle = "";
+		if (placeholder && image.blurhash) {
+			const { blurhashToImageCssString } = await import("@unpic/placeholder");
+			placeholderStyle = blurhashToImageCssString(image.blurhash);
+		} else if (placeholder && image.dominantColor) {
+			placeholderStyle = `background-color: ${image.dominantColor};`;
+		}
+
+		return {
+			key: image._key,
+			alt,
+			caption: image.caption,
+			width,
+			height,
+			src,
+			srcset,
+			sizes,
+			astroImageSrc,
+			placeholderStyle,
+		};
+	}),
+);
 ---
 
 <div class="emdash-gallery" style={`--columns: ${columns}`}>
 	{
-		images.map((image) => {
-			const src = buildRenderMediaUrl(Astro.locals.emdash?.getPublicMediaUrl, {
-				url: image.asset.url,
-				id: image.asset._ref,
-			});
-			const hasSize = image.width && image.height;
-			return (
-				<figure class="emdash-gallery-item">
-					{hasSize ? (
-						<AstroImage
-							src={src}
-							alt={image.alt || ""}
-							width={image.width!}
-							height={image.height!}
-							layout="constrained"
-						/>
-					) : (
-						<img src={src} alt={image.alt || ""} loading="lazy" decoding="async" />
-					)}
-					{image.caption && <figcaption>{image.caption}</figcaption>}
-				</figure>
-			);
-		})
+		resolvedImages.map((image) => (
+			<figure class="emdash-gallery-item" style={image.placeholderStyle || undefined}>
+				{image.astroImageSrc ? (
+					<AstroImage
+						src={image.astroImageSrc}
+						alt={image.alt}
+						width={image.width!}
+						height={image.height!}
+						layout="constrained"
+					/>
+				) : (
+					<img
+						src={image.src}
+						srcset={image.srcset}
+						sizes={image.sizes}
+						alt={image.alt}
+						width={image.width}
+						height={image.height}
+						loading="lazy"
+						decoding="async"
+					/>
+				)}
+				{image.caption && <figcaption>{image.caption}</figcaption>}
+			</figure>
+		))
 	}
 </div>
 

package/src/components/widgets/Categories.astro

@@ -12,7 +12,7 @@ interface Props {
 
 const { showCount = true, hierarchical = true } = Astro.props;
 
-const categories = await getTaxonomyTerms("category");
+const categories = await getTaxonomyTerms("category", { includeCounts: showCount });
 ---
 
 <ul class="widget-categories">

package/src/components/widgets/Tags.astro

@@ -12,7 +12,7 @@ interface Props {
 
 const { showCount = false, limit = 20 } = Astro.props;
 
-const allTags = await getTaxonomyTerms("tag");
+const allTags = await getTaxonomyTerms("tag", { includeCounts: showCount });
 const tags = allTags.slice(0, limit);
 ---
 

package/src/config/secrets.ts

@@ -108,8 +108,9 @@ export interface ResolveSecretsOptions {
 	db: Kysely<Database>;
 	/**
 	 * Optional explicit env override map. When omitted, falls back to
-	 * `import.meta.env` via the global accessor below. Tests pass an
-	 * explicit map to avoid leaking process state.
+	 * `process.env` via `readDefaultEnv` below (never `import.meta.env` —
+	 * see that function's docstring). Tests pass an explicit map to avoid
+	 * leaking process state.
 	 */
 	env?: SecretsEnv;
 	/**
@@ -514,29 +515,34 @@ function decodeBase64urlStrict(input: string): Uint8Array | null {
 /**
  * Default env reader.
  *
- * Note: this is the **only** code path in core that reads both
- * `import.meta.env` and `process.env`. Route handlers should not — they
- * always run inside the Astro/Vite bundle where `import.meta.env` is
- * the correct source. This resolver is shared with the CLI surface (via
- * `cli/commands/secrets.ts`) which runs outside the bundle, so we
- * deliberately consult both. `import.meta.env` wins so build-time
- * substitutions are honored when present.
+ * Reads **only** `process.env`. This module must never reference
+ * `import.meta.env`: in an Astro/Vite production build the bare
+ * `import.meta.env` expression is statically replaced with an object
+ * literal built from the env loaded at build time, which (a) embeds any
+ * secret present in `.env` on the build machine into the shipped server
+ * bundle, and (b) makes that stale build-time value silently shadow the
+ * real runtime secret configured on the deployment platform (e.g. via
+ * `wrangler secret put`). See #2139.
+ *
+ * `process.env` is the runtime source on Node/container deployments and
+ * on Cloudflare Workers with Node compatibility (the same source
+ * `resolveS3Config` in `../storage/s3.ts` uses). The CLI surface
+ * (`cli/commands/secrets.ts`) runs outside the bundle where
+ * `process.env` is native.
  *
  * The convention documented in AGENTS.md ("import.meta.env.EMDASH_X ||
- * import.meta.env.X") is the route-handler convention; this is the
- * shared-with-CLI exception.
+ * import.meta.env.X") is for public, build-time config in route
+ * handlers; secrets are deliberately excluded from it.
  */
 function readDefaultEnv(): SecretsEnv {
-	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- import.meta.env is loose by design
-	const meta = (import.meta.env ?? {}) as Record<string, string | undefined>;
 	const proc = typeof process !== "undefined" && process.env ? process.env : {};
 
 	return {
-		EMDASH_ENCRYPTION_KEY: meta.EMDASH_ENCRYPTION_KEY ?? proc.EMDASH_ENCRYPTION_KEY,
-		EMDASH_PREVIEW_SECRET: meta.EMDASH_PREVIEW_SECRET ?? proc.EMDASH_PREVIEW_SECRET,
-		PREVIEW_SECRET: meta.PREVIEW_SECRET ?? proc.PREVIEW_SECRET,
-		EMDASH_IP_SALT: meta.EMDASH_IP_SALT ?? proc.EMDASH_IP_SALT,
-		EMDASH_AUTH_SECRET: meta.EMDASH_AUTH_SECRET ?? proc.EMDASH_AUTH_SECRET,
-		AUTH_SECRET: meta.AUTH_SECRET ?? proc.AUTH_SECRET,
+		EMDASH_ENCRYPTION_KEY: proc.EMDASH_ENCRYPTION_KEY,
+		EMDASH_PREVIEW_SECRET: proc.EMDASH_PREVIEW_SECRET,
+		PREVIEW_SECRET: proc.PREVIEW_SECRET,
+		EMDASH_IP_SALT: proc.EMDASH_IP_SALT,
+		EMDASH_AUTH_SECRET: proc.EMDASH_AUTH_SECRET,
+		AUTH_SECRET: proc.AUTH_SECRET,
 	};
 }

package/src/content/converters/gallery.ts

@@ -0,0 +1,61 @@
+/**
+ * Shared sanitization for gallery block images, used by both converters so
+ * the editor round-trip and the stored shape stay in lockstep.
+ */
+
+import type { PortableTextGalleryImage } from "./types.js";
+
+/**
+ * Normalize an untrusted `images` value into well-formed gallery images.
+ * Non-object entries and entries without an asset object are dropped.
+ * Missing `_key`s are filled via `generateKey` when provided (PM → PT);
+ * left empty otherwise (PT → PM keeps whatever the block carried).
+ */
+export function sanitizeGalleryImages(
+	value: unknown,
+	generateKey?: () => string,
+): PortableTextGalleryImage[] {
+	if (!Array.isArray(value)) return [];
+
+	const images: PortableTextGalleryImage[] = [];
+	for (const entry of value as unknown[]) {
+		if (!isRecord(entry)) continue;
+		const record = entry;
+		const asset = record.asset;
+		if (!isRecord(asset)) continue;
+		const assetRecord = asset;
+
+		const image: PortableTextGalleryImage = {
+			_type: "image",
+			_key:
+				typeof record._key === "string" && record._key
+					? record._key
+					: generateKey
+						? generateKey()
+						: "",
+			asset: {
+				_type: "reference",
+				_ref: typeof assetRecord._ref === "string" ? assetRecord._ref : "",
+				...(typeof assetRecord.url === "string" && assetRecord.url ? { url: assetRecord.url } : {}),
+				...(typeof assetRecord.provider === "string" && assetRecord.provider
+					? { provider: assetRecord.provider }
+					: {}),
+			},
+		};
+		if (typeof record.alt === "string" && record.alt) image.alt = record.alt;
+		if (typeof record.caption === "string" && record.caption) image.caption = record.caption;
+		if (typeof record.width === "number") image.width = record.width;
+		if (typeof record.height === "number") image.height = record.height;
+		if (typeof record.blurhash === "string" && record.blurhash) image.blurhash = record.blurhash;
+		if (typeof record.dominantColor === "string" && record.dominantColor)
+			image.dominantColor = record.dominantColor;
+
+		images.push(image);
+	}
+
+	return images;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/content/converters/portable-text-to-prosemirror.ts

@@ -4,6 +4,7 @@
  * Converts Portable Text to TipTap's ProseMirror JSON format for editing.
  */
 
+import { sanitizeGalleryImages } from "./gallery.js";
 import type {
 	ProseMirrorDocument,
 	ProseMirrorNode,
@@ -13,6 +14,7 @@ import type {
 	PortableTextSpan,
 	PortableTextMarkDef,
 	PortableTextImageBlock,
+	PortableTextGalleryBlock,
 	PortableTextCodeBlock,
 } from "./types.js";
 
@@ -128,6 +130,14 @@ function isImageBlock(block: PortableTextBlock): block is PortableTextImageBlock
 	);
 }
 
+/**
+ * Type guard for gallery blocks. Requires an `images` array — a gallery
+ * without one is malformed and falls through to the unknown-block path.
+ */
+function isGalleryBlock(block: PortableTextBlock): block is PortableTextGalleryBlock {
+	return block._type === "gallery" && "images" in block && Array.isArray(block.images);
+}
+
 /**
  * Type guard for code blocks
  */
@@ -149,6 +159,15 @@ function convertBlock(block: PortableTextBlock): ProseMirrorNode | null {
 		// Malformed image block (no asset wrapper) — extract url from top level
 		return convertMalformedImage(block);
 	}
+	if (isGalleryBlock(block)) {
+		return {
+			type: "gallery",
+			attrs: {
+				images: sanitizeGalleryImages(block.images),
+				columns: typeof block.columns === "number" ? block.columns : undefined,
+			},
+		};
+	}
 	if (isCodeBlock(block)) {
 		return convertCodeBlock(block);
 	}

package/src/content/converters/prosemirror-to-portable-text.ts

@@ -4,6 +4,7 @@
  * Converts TipTap's ProseMirror JSON format to Portable Text for storage.
  */
 
+import { sanitizeGalleryImages } from "./gallery.js";
 import type {
 	ProseMirrorDocument,
 	ProseMirrorNode,
@@ -13,6 +14,7 @@ import type {
 	PortableTextSpan,
 	PortableTextMarkDef,
 	PortableTextImageBlock,
+	PortableTextGalleryBlock,
 	PortableTextCodeBlock,
 	PortableTextHtmlBlock,
 } from "./types.js";
@@ -77,6 +79,9 @@ function convertNode(node: ProseMirrorNode): PortableTextBlock | PortableTextBlo
 		case "image":
 			return convertImage(node);
 
+		case "gallery":
+			return convertGallery(node);
+
 		case "horizontalRule":
 			return {
 				_type: "break",
@@ -327,6 +332,19 @@ function convertImage(node: ProseMirrorNode): PortableTextImageBlock {
 	};
 }
 
+/**
+ * Convert gallery node to Portable Text
+ */
+function convertGallery(node: ProseMirrorNode): PortableTextGalleryBlock {
+	const columns = node.attrs?.columns;
+	return {
+		_type: "gallery",
+		_key: generateKey(),
+		images: sanitizeGalleryImages(node.attrs?.images, generateKey),
+		...(typeof columns === "number" ? { columns } : {}),
+	};
+}
+
 /**
  * Convert inline content (text nodes with marks) to Portable Text spans
  */

package/src/content/converters/types.ts

@@ -70,6 +70,41 @@ export interface PortableTextImageBlock {
 	displayHeight?: number;
 }
 
+/**
+ * A single image inside a gallery block. Mirrors the shape produced by
+ * gutenberg-to-portable-text and consumed by Gallery.astro.
+ */
+export interface PortableTextGalleryImage {
+	_type: "image";
+	_key: string;
+	asset: {
+		/** Present on WordPress-imported galleries; always emitted on round-trip */
+		_type?: "reference";
+		_ref: string;
+		url?: string;
+		/** Provider ID for external media (e.g., "cloudflare-images") */
+		provider?: string;
+	};
+	alt?: string;
+	caption?: string;
+	width?: number;
+	height?: number;
+	/** LQIP blurhash placeholder (images only) */
+	blurhash?: string;
+	/** LQIP dominant-color placeholder, as a CSS color (images only) */
+	dominantColor?: string;
+}
+
+/**
+ * Gallery block (grid of images with optional per-image captions)
+ */
+export interface PortableTextGalleryBlock {
+	_type: "gallery";
+	_key: string;
+	images: PortableTextGalleryImage[];
+	columns?: number;
+}
+
 /**
  * Code block
  */
@@ -105,6 +140,7 @@ export interface PortableTextUnknownBlock {
 export type PortableTextBlock =
 	| PortableTextTextBlock
 	| PortableTextImageBlock
+	| PortableTextGalleryBlock
 	| PortableTextCodeBlock
 	| PortableTextHtmlBlock
 	| PortableTextUnknownBlock;

package/src/database/dialect-helpers.ts

@@ -11,7 +11,7 @@
  */
 
 import type { ColumnDataType, Kysely, RawBuilder } from "kysely";
-import { sql } from "kysely";
+import { PostgresAdapter, sql } from "kysely";
 
 import type { DatabaseDialectType } from "../db/adapters.js";
 import { validateIdentifier, validateJsonFieldName } from "./validate.js";
@@ -19,12 +19,11 @@ import { validateIdentifier, validateJsonFieldName } from "./validate.js";
 export type { DatabaseDialectType };
 
 /**
- * Detect dialect type from a Kysely instance via the adapter class name.
+ * Detect dialect type from a Kysely instance via the adapter class.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
 export function detectDialect(db: Kysely<any>): DatabaseDialectType {
-	const name = db.getExecutor().adapter.constructor.name;
-	if (name === "PostgresAdapter") return "postgres";
+	if (db.getExecutor().adapter instanceof PostgresAdapter) return "postgres";
 	return "sqlite";
 }
 

package/src/database/pg-migration-lock.ts

@@ -38,10 +38,7 @@ const KYSELY_PG_MIGRATION_LOCK_ID = BigInt("3853314791062309107");
 
 /**
  * Extends the stock adapter so every capability flag and `instanceof` check
- * is inherited, and keeps the class NAME `PostgresAdapter` because
- * `detectDialect()` (dialect-helpers.ts) identifies the dialect via
- * `adapter.constructor.name` — a differently-named adapter would make every
- * dialect helper fall back to SQLite SQL against a Postgres database.
+ * is inherited.
  */
 class PostgresAdapter extends KyselyPostgresAdapter {
 	// eslint-disable-next-line typescript/no-explicit-any -- matches the DialectAdapter signature

package/src/emdash-runtime.ts

@@ -36,6 +36,8 @@ import type {
 	ContentDateField,
 } from "./database/repositories/types.js";
 import { validateIdentifier } from "./database/validate.js";
+import { getI18nConfig } from "./i18n/config.js";
+import { repairLocaleCasing } from "./i18n/repair-locale-casing.js";
 import { normalizeMediaValue } from "./media/normalize.js";
 import type { MediaProvider, MediaProviderCapabilities } from "./media/types.js";
 import {
@@ -71,6 +73,12 @@ import { createSingleFlightCache, singleFlightCached } from "./utils/single-flig
 import { COMMIT, VERSION } from "./version.js";
 
 const LEADING_SLASH_PATTERN = /^\//;
+const LOCALE_CASING_REPAIR_OPTION = "emdash:repair_locale_casing";
+
+function getLocaleCasingRepairVersion(locales: readonly string[]): string | null {
+	if (locales.length === 0) return null;
+	return `1:${locales.toSorted().join(",")}`;
+}
 
 /**
  * Parse a JSON column expected to contain an array of strings.
@@ -1130,6 +1138,10 @@ export class EmDashRuntime {
 		const storage = EmDashRuntime.getStorage(deps);
 
 		let pluginStates: Map<string, string> = new Map();
+		const configuredLocales: string[] =
+			virtualConfig?.i18n?.locales ?? getI18nConfig()?.locales ?? [];
+		const localeCasingRepairVersion = getLocaleCasingRepairVersion(configuredLocales);
+		let storedLocaleCasingRepairVersion: string | undefined;
 		let siteInfo:
 			| {
 					siteName?: string;
@@ -1175,7 +1187,9 @@ export class EmDashRuntime {
 				"emdash:site_title",
 				"emdash:site_url",
 				"emdash:locale",
+				LOCALE_CASING_REPAIR_OPTION,
 			]);
+			storedLocaleCasingRepairVersion = siteOpts.get(LOCALE_CASING_REPAIR_OPTION);
 			return {
 				siteName: siteOpts.get("emdash:site_title") ?? undefined,
 				siteUrl: siteOpts.get("emdash:site_url") ?? undefined,
@@ -1241,6 +1255,20 @@ export class EmDashRuntime {
 
 		await Promise.all(coldStartReads);
 
+		if (
+			localeCasingRepairVersion &&
+			(configuredLocales.some(
+				(locale) => locale.includes("-") || locale !== locale.toLowerCase(),
+			) ||
+				storedLocaleCasingRepairVersion !== undefined) &&
+			storedLocaleCasingRepairVersion !== localeCasingRepairVersion
+		) {
+			await phase("rt.locale", "Repair locale casing", async () => {
+				await repairLocaleCasing(db, configuredLocales);
+				await new OptionsRepository(db).set(LOCALE_CASING_REPAIR_OPTION, localeCasingRepairVersion);
+			});
+		}
+
 		// Auto-seed the default schema for a first load that skipped the setup
 		// wizard (the wizard and dev-bypass apply seeds explicitly). Run under a
 		// per-isolate lock keyed by the configured db so a reclaimed-and-rerun
@@ -2965,7 +2993,7 @@ export class EmDashRuntime {
 			await this.refreshContentUsageAfterSuccessfulWrite(collection, [result.data.id]);
 		}
 
-		// Run afterDelete hooks (fire-and-forget)
+		// Run afterDelete hooks (deferred past the response via after())
 		if (result.success) {
 			this.runAfterDeleteHooks(id, collection, false);
 		}
@@ -3052,7 +3080,7 @@ export class EmDashRuntime {
 			await this.refreshContentUsageAfterSuccessfulWrite(collection, [result.data.item.id]);
 		}
 
-		// Run afterUnpublish hooks (fire-and-forget)
+		// Run afterUnpublish hooks (deferred past the response via after())
 		if (result.success && result.data) {
 			this.runAfterUnpublishHooks(contentItemToRecord(result.data.item), collection);
 		}
@@ -3746,24 +3774,34 @@ export class EmDashRuntime {
 	}
 
 	private runAfterDeleteHooks(id: string, collection: string, permanent: boolean): void {
-		// Trusted plugins
-		if (this.hooks.hasHooks("content:afterDelete")) {
-			this.hooks
-				.runContentAfterDelete(id, collection, permanent)
-				.catch((err) => console.error("EmDash afterDelete hook error:", err));
-		}
+		after(async () => {
+			// Trusted plugins
+			if (this.hooks.hasHooks("content:afterDelete")) {
+				try {
+					await this.hooks.runContentAfterDelete(id, collection, permanent);
+				} catch (err) {
+					console.error("EmDash afterDelete hook error:", err);
+				}
+			}
 
-		// Sandboxed plugins
-		for (const [pluginKey, plugin] of this.sandboxedPlugins) {
-			const [pluginId] = pluginKey.split(":");
-			if (!pluginId || !this.isPluginEnabled(pluginId)) continue;
+			// Sandboxed plugins
+			const tasks: Promise<void>[] = [];
+			for (const [pluginKey, plugin] of this.sandboxedPlugins) {
+				const [pluginId] = pluginKey.split(":");
+				if (!pluginId || !this.isPluginEnabled(pluginId)) continue;
 
-			plugin
-				.invokeHook("content:afterDelete", { id, collection, permanent })
-				.catch((err) =>
-					console.error(`EmDash: Sandboxed plugin ${pluginId} afterDelete error:`, err),
+				tasks.push(
+					(async () => {
+						try {
+							await plugin.invokeHook("content:afterDelete", { id, collection, permanent });
+						} catch (err) {
+							console.error(`EmDash: Sandboxed plugin ${pluginId} afterDelete error:`, err);
+						}
+					})(),
 				);
-		}
+			}
+			await Promise.allSettled(tasks);
+		});
 	}
 
 	private runDeferredContentHook(

package/src/i18n/config.ts

@@ -30,6 +30,14 @@ export function getI18nConfig(): I18nConfig | null {
 	return _config ?? null;
 }
 
+/** Match a locale to the exact casing used by the site configuration. */
+export function resolveConfiguredLocale(locale: string): string {
+	return (
+		_config?.locales.find((configured) => configured.toLowerCase() === locale.toLowerCase()) ??
+		locale
+	);
+}
+
 /**
  * Check if i18n is enabled.
  * Returns true when multiple locales are configured.