emdash 0.24.1 → 0.26.0

package/src/api/handlers/seo.ts

@@ -56,6 +56,34 @@ export interface SitemapDataResponse {
 /** Maximum entries per sitemap (per spec) */
 const SITEMAP_MAX_ENTRIES = 50_000;
 
+/** Matches a trailing timezone designator (`Z` or `±HH`, `±HHMM`, `±HH:MM`). */
+const TZ_SUFFIX_RE = /([zZ]|[+-]\d{2}(:?\d{2})?)$/;
+
+/**
+ * Normalize a stored timestamp to W3C Datetime (ISO 8601) for sitemaps.
+ *
+ * `updated_at` is not guaranteed to be ISO: the column default is
+ * `datetime('now')` on SQLite and `CURRENT_TIMESTAMP` on Postgres, both of
+ * which store a space-separated `YYYY-MM-DD HH:MM:SS` string (and imported
+ * content can carry other shapes). The sitemap `<lastmod>` field requires
+ * W3C Datetime, and Google Search Console rejects the space-separated form
+ * as "Invalid date". Normalize defensively, assuming UTC when no offset is
+ * present (matches SQLite's `datetime('now')`). Valid date strings are
+ * normalized to UTC ISO 8601; unparseable values are returned as-is.
+ */
+function toW3CDate(value: string): string {
+	if (!value) return value;
+	let normalized = value.trim();
+	if (normalized.includes(" ") && !normalized.includes("T")) {
+		normalized = normalized.replace(" ", "T");
+	}
+	if (!TZ_SUFFIX_RE.test(normalized)) {
+		normalized += "Z";
+	}
+	const parsed = Date.parse(normalized);
+	return Number.isNaN(parsed) ? value : new Date(parsed).toISOString();
+}
+
 /**
  * Collect all published, indexable content across SEO-enabled collections
  * for sitemap generation, grouped by collection.
@@ -133,7 +161,7 @@ export async function handleSitemapData(
 					entries.push({
 						id: row.id,
 						slug: row.slug,
-						updatedAt: row.updated_at,
+						updatedAt: toW3CDate(row.updated_at),
 						locale: row.locale,
 						translationGroup: row.translation_group,
 						image: row.seo_image ?? null,
@@ -144,7 +172,7 @@ export async function handleSitemapData(
 					collection: col.slug,
 					urlPattern: col.url_pattern,
 					// Rows are ordered by updated_at DESC, so first row is the latest
-					lastmod: rows.rows[0].updated_at,
+					lastmod: toW3CDate(rows.rows[0].updated_at),
 					entries,
 				});
 			} catch (err) {

package/src/api/handlers/taxonomies.ts

@@ -12,7 +12,7 @@ import { ulid } from "ulidx";
 
 import { TaxonomyRepository } from "../../database/repositories/taxonomy.js";
 import type { Database, TaxonomyDefTable } from "../../database/types.js";
-import { invalidateTermCache } from "../../taxonomies/index.js";
+import { invalidateTaxonomyDefsCache, invalidateTermCache } from "../../taxonomies/index.js";
 import type { ApiResult } from "../types.js";
 
 const NAME_PATTERN = /^[a-z][a-z0-9_]*$/;
@@ -290,6 +290,10 @@ export async function handleTaxonomyCreate(
 			})
 			.execute();
 
+		// A new def changes which taxonomies exist — drop the isolate-wide
+		// defs/names caches so this isolate reflects it immediately.
+		invalidateTaxonomyDefsCache();
+
 		const row = await db
 			.selectFrom("_emdash_taxonomy_defs")
 			.selectAll()

package/src/api/schemas/schema.ts

@@ -125,6 +125,7 @@ export const createFieldBody = z
 export const updateFieldBody = z
 	.object({
 		label: z.string().min(1).optional(),
+		type: fieldTypeValues.optional(),
 		required: z.boolean().optional(),
 		unique: z.boolean().optional(),
 		defaultValue: z.unknown().optional(),

package/src/astro/integration/virtual-modules.ts

@@ -242,6 +242,21 @@ export function generatePluginsModule(descriptors: PluginDescriptor[]): string {
 	let needsAdapter = false;
 
 	descriptors.forEach((descriptor, index) => {
+		// Every `plugins: []` entry must resolve to a file/package entrypoint that
+		// can be statically imported and bundled at build time. An in-process
+		// `definePlugin({...})` result passed directly has no entrypoint; without
+		// this guard the generator emitted `import pluginDefN from "undefined";`,
+		// which failed deep in Rollup with `failed to resolve import "undefined"`
+		// (#1416). Fail fast with an actionable message instead.
+		if (!descriptor.entrypoint) {
+			throw new Error(
+				`[emdash] Plugin "${descriptor.id}" has no \`entrypoint\`. The astro integration's ` +
+					`\`plugins: []\` requires plugins that resolve to a file/package entrypoint so they can be ` +
+					`bundled at build time; an in-process \`definePlugin({...})\` result passed directly is not ` +
+					`supported. Move the plugin into its own module and reference it via a factory that returns ` +
+					`a descriptor with an \`entrypoint\` (e.g. \`plugins: [myPlugin()]\`).`,
+			);
+		}
 		if (descriptor.format === "standard") {
 			// Standard format: import default export, wrap with adaptSandboxEntry
 			needsAdapter = true;

package/src/astro/middleware.ts

@@ -490,6 +490,18 @@ export const onRequest = defineMiddleware(async (context, next) => {
 		const sessionUser =
 			context.isPrerendered || !hasSessionCookie ? null : await resolveSessionUser(context.session);
 
+		// Credentialed API requests (API tokens `ec_pat_*`, OAuth tokens
+		// `ec_oat_*`, and other Bearer credentials) carry no `astro-session`
+		// cookie, so `sessionUser` is null for them -- yet they still expect
+		// read-your-writes. The auth middleware that resolves the token runs
+		// *after* this one, so `locals.user` isn't populated here; detect the
+		// credential directly on the request. Request-scoped adapters use this to
+		// keep such requests on the primary/uncached connection (not a lagging
+		// read replica or the Hyperdrive query cache).
+		const hasBearerAuth = (request.headers.get("authorization") ?? "")
+			.toLowerCase()
+			.startsWith("bearer ");
+
 		if (!isEmDashRoute && !isPublicRuntimeRoute && !hasEditCookie && !hasPreviewToken) {
 			if (!sessionUser && !playgroundDb) {
 				const timings: Array<{ name: string; dur: number; desc?: string }> = [];
@@ -668,6 +680,7 @@ export const onRequest = defineMiddleware(async (context, next) => {
 					// Content handlers
 					handleContentList: runtime.handleContentList.bind(runtime),
 					handleContentGet: runtime.handleContentGet.bind(runtime),
+					handleContentAuthors: runtime.handleContentAuthors.bind(runtime),
 					handleContentCreate: runtime.handleContentCreate.bind(runtime),
 					handleContentUpdate: runtime.handleContentUpdate.bind(runtime),
 					handleContentDelete: runtime.handleContentDelete.bind(runtime),
@@ -775,7 +788,7 @@ export const onRequest = defineMiddleware(async (context, next) => {
 			// per-request state (e.g. a D1 bookmark cookie for read-your-writes).
 			const scoped = createRequestScopedDb({
 				config: config?.database?.config,
-				isAuthenticated: !!sessionUser,
+				isAuthenticated: !!sessionUser || hasBearerAuth,
 				isWrite: request.method !== "GET" && request.method !== "HEAD",
 				cookies: context.cookies,
 				url,

package/src/astro/routes/api/import/wordpress/media.ts

@@ -20,6 +20,7 @@ import { apiError, apiSuccess, handleError } from "#api/error.js";
 import { isParseError, parseBody } from "#api/parse.js";
 import { wpMediaImportBody } from "#api/schemas.js";
 import { validateExternalUrl, ssrfSafeFetch, SsrfError } from "#import/ssrf.js";
+import { enrichImageMetadata } from "#media/enrich.js";
 import type { EmDashHandlers } from "#types";
 
 import type { AttachmentInfo } from "./analyze.js";
@@ -125,7 +126,7 @@ export const POST: APIRoute = async ({ request, locals }) => {
 	}
 };
 
-async function importMediaWithProgress(
+export async function importMediaWithProgress(
 	attachments: AttachmentInfo[],
 	db: NonNullable<EmDashHandlers["db"]>,
 	storage: NonNullable<EmDashHandlers["storage"]>,
@@ -273,6 +274,9 @@ async function importMediaWithProgress(
 				contentType,
 			});
 
+			// Derive dimensions + LQIP placeholders (no-op for non-images).
+			const enriched = await enrichImageMetadata(new Uint8Array(buffer), contentType);
+
 			// Create media record with content hash
 			const mediaItem = await repo.create({
 				filename: attachment.filename || `media-${attachment.id}${ext}`,
@@ -280,8 +284,10 @@ async function importMediaWithProgress(
 				size,
 				storageKey,
 				contentHash,
-				width: undefined,
-				height: undefined,
+				width: enriched.width,
+				height: enriched.height,
+				blurhash: enriched.blurhash,
+				dominantColor: enriched.dominantColor,
 			});
 
 			// Build the new URL

package/src/astro/routes/api/media/[id]/confirm.ts

@@ -14,10 +14,20 @@ import { requireOwnerPerm, requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError } from "#api/error.js";
 import { isParseError, parseOptionalBody } from "#api/parse.js";
 import { mediaConfirmBody } from "#api/schemas.js";
+import { enrichImageMetadata } from "#media/enrich.js";
 import type { MediaItem } from "#types";
 
 export const prerender = false;
 
+/**
+ * Max raw bytes to buffer for server-side LQIP generation at confirm time. The
+ * signed-URL upload flow exists so large files bypass server buffering — re-reading
+ * the whole object into a Worker's 128 MB heap to compute a blurhash would OOM
+ * on the very uploads that flow was designed for. LQIP is progressive
+ * enhancement: large images simply ship without a server-generated placeholder.
+ */
+const MAX_PLACEHOLDER_DOWNLOAD_BYTES = 8 * 1024 * 1024;
+
 /**
  * Add URL to media item (relative URL for portability)
  */
@@ -81,11 +91,61 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 			}
 		}
 
+		// For images, read the just-uploaded bytes back from storage once to
+		// generate LQIP placeholders (and server-side dimensions as a fallback).
+		// The signed-URL flow uploads directly to storage, so this confirm is the
+		// only point at which the server sees the bytes. Best-effort: a decode
+		// failure must not block the upload from being marked ready. We also cap
+		// the download size — buffering a large original into a Worker heap to
+		// compute a 32px blurhash would OOM on the uploads the signed-URL path
+		// exists to support, so oversized files skip the server-side placeholder.
+		let blurhash: string | undefined;
+		let dominantColor: string | undefined;
+		let width = body.width;
+		let height = body.height;
+		if (emdash.storage && existing.mimeType.startsWith("image/")) {
+			const knownSize = body.size ?? existing.size ?? undefined;
+			const tooLarge = knownSize != null && knownSize > MAX_PLACEHOLDER_DOWNLOAD_BYTES;
+			if (!tooLarge) {
+				try {
+					const { body: stream } = await emdash.storage.download(existing.storageKey);
+					const bytes = new Uint8Array(await new Response(stream).arrayBuffer());
+					// Defense-in-depth for the unknown-size case: even though we
+					// already buffered it, refuse the decode so we don't also pay
+					// the (larger) RGBA allocation.
+					if (bytes.byteLength > MAX_PLACEHOLDER_DOWNLOAD_BYTES) {
+						console.warn(
+							`[media] confirm skipping placeholder: object ${existing.storageKey} is ${bytes.byteLength} bytes (> ${MAX_PLACEHOLDER_DOWNLOAD_BYTES})`,
+						);
+					} else {
+						const enriched = await enrichImageMetadata(bytes, existing.mimeType, {
+							knownDimensions:
+								body.width != null && body.height != null
+									? { width: body.width, height: body.height }
+									: undefined,
+						});
+						blurhash = enriched.blurhash;
+						dominantColor = enriched.dominantColor;
+						width = width ?? enriched.width;
+						height = height ?? enriched.height;
+					}
+				} catch (error) {
+					console.error("[media] confirm placeholder generation failed:", error);
+				}
+			} else {
+				console.warn(
+					`[media] confirm skipping placeholder: object ${existing.storageKey} reported size ${knownSize} bytes (> ${MAX_PLACEHOLDER_DOWNLOAD_BYTES})`,
+				);
+			}
+		}
+
 		// Confirm the upload
 		const item = await repo.confirmUpload(id, {
 			size: body.size,
-			width: body.width,
-			height: body.height,
+			width,
+			height,
+			blurhash,
+			dominantColor,
 		});
 
 		if (!item) {

package/src/astro/routes/api/media.ts

@@ -16,8 +16,8 @@ import { GLOBAL_UPLOAD_ALLOWLIST, resolveFieldAllowlist } from "#api/handlers/me
 import { isParseError, parseQuery } from "#api/parse.js";
 import { DEFAULT_MAX_UPLOAD_SIZE, formatFileSize, mediaListQuery } from "#api/schemas.js";
 import { MediaRepository } from "#db/repositories/media.js";
+import { enrichImageMetadata } from "#media/enrich.js";
 import { matchesMimeAllowlist, normalizeMime } from "#media/mime.js";
-import { generatePlaceholder } from "#media/placeholder.js";
 import { computeContentHash } from "#utils/hash.js";
 
 import type { MediaItem } from "../../types.js";
@@ -163,34 +163,32 @@ export const POST: APIRoute = async ({ request, locals }) => {
 		const width = widthStr ? parseInt(widthStr, 10) : undefined;
 		const height = heightStr ? parseInt(heightStr, 10) : undefined;
 
-		// Generate placeholder data for images.
-		// If the client sent a thumbnail (small pre-resized image), use that
-		// instead of the full buffer to avoid OOM on memory-constrained runtimes.
+		// Derive dimensions + LQIP placeholders via the shared helper.
+		// If the client sent a downscaled thumbnail, decode that for the blurhash
+		// (avoids OOM on large originals on memory-constrained runtimes).
 		const thumbnailEntry = formData.get("thumbnail");
 		const thumbnail = thumbnailEntry instanceof File ? thumbnailEntry : null;
-
-		let placeholder: Awaited<ReturnType<typeof generatePlaceholder>> = null;
-		if (file.type.startsWith("image/")) {
-			if (thumbnail) {
-				const thumbBuffer = new Uint8Array(await thumbnail.arrayBuffer());
-				placeholder = await generatePlaceholder(thumbBuffer, thumbnail.type);
-			} else {
-				const clientDims = width && height ? { width, height } : undefined;
-				placeholder = await generatePlaceholder(buffer, file.type, clientDims);
-			}
-		}
+		const enriched = await enrichImageMetadata(buffer, file.type, {
+			knownDimensions: width != null && height != null ? { width, height } : undefined,
+			placeholder: thumbnail
+				? { bytes: new Uint8Array(await thumbnail.arrayBuffer()), contentType: thumbnail.type }
+				: undefined,
+		});
 
 		// Create media record
 		const result = await emdash.handleMediaCreate({
 			filename: file.name,
 			mimeType: normalizeMime(file.type),
 			size: file.size,
-			width,
-			height,
+			// Client dimensions win over server header dimensions: the browser's
+			// naturalWidth/Height apply EXIF orientation, while image-size reports
+			// raw (pre-orientation) header dims — swapped for 90°/270° JPEGs.
+			width: width ?? enriched.width,
+			height: height ?? enriched.height,
 			storageKey,
 			contentHash,
-			blurhash: placeholder?.blurhash,
-			dominantColor: placeholder?.dominantColor,
+			blurhash: enriched.blurhash,
+			dominantColor: enriched.dominantColor,
 			authorId: user?.id,
 		});
 

package/src/astro/routes/sitemap-[collection].xml.ts

@@ -138,11 +138,12 @@ export const GET: APIRoute = async ({ params, locals, url }) => {
 				lines.push("    </image:image>");
 			}
 
-			if (useXhtml && siblings && siblings.length > 1) {
+			const alternateEntries = siblings ?? (useXhtml ? [entry] : null);
+			if (useXhtml && alternateEntries) {
 				// Emit one xhtml:link per sibling (including self -- Google
 				// recommends including the page's own hreflang annotation).
 				// Siblings with unroutable locales are skipped here too.
-				for (const sib of siblings) {
+				for (const sib of alternateEntries) {
 					const sibLoc = await resolveEntryUrl(sib);
 					if (sibLoc === null) continue;
 					lines.push(
@@ -154,13 +155,13 @@ export const GET: APIRoute = async ({ params, locals, url }) => {
 				// the first sibling with a routable URL. Stable order:
 				// rows arrive sorted by updated_at DESC from the handler.
 				const defaultSibling =
-					i18nConfig && siblings.find((s) => s.locale === i18nConfig.defaultLocale);
+					i18nConfig && alternateEntries.find((s) => s.locale === i18nConfig.defaultLocale);
 				let xDefaultLoc: string | null = null;
 				if (defaultSibling) {
 					xDefaultLoc = await resolveEntryUrl(defaultSibling);
 				}
 				if (xDefaultLoc === null) {
-					for (const sib of siblings) {
+					for (const sib of alternateEntries) {
 						const sibLoc = await resolveEntryUrl(sib);
 						if (sibLoc !== null) {
 							xDefaultLoc = sibLoc;

package/src/components/EmDashHead.astro

@@ -17,8 +17,14 @@
  * ```
  */
 import type { PublicPageContext, PageMetadataContribution } from "../plugins/types.js";
-import { resolvePageMetadata, renderPageMetadata } from "../page/metadata.js";
+import {
+	createSha256CspHash,
+	resolvePageMetadata,
+	renderPageMetadata,
+	type ResolvedPageMetadata,
+} from "../page/metadata.js";
 import { renderFragments } from "../page/fragments.js";
+import JsonLdScript from "./JsonLdScript.astro";
 import {
 	generateBaseSeoContributions,
 	generateSiteSeoContributions,
@@ -38,6 +44,7 @@ const runtime = getPageRuntime(Astro.locals as Record<string, unknown>);
 let metadataHtml = "";
 let siteIdentityHtml = "";
 let fragmentsHtml = "";
+let jsonLdScripts: ResolvedPageMetadata["jsonld"] = [];
 
 if (runtime) {
 	// Run independent async loads in parallel: site settings (SEO meta
@@ -79,17 +86,30 @@ if (runtime) {
 	const siteContributions = generateSiteSeoContributions(siteSettings.seo);
 	const allContributions = [...pluginContributions, ...siteContributions, ...baseContributions];
 	const resolved = resolvePageMetadata(allContributions);
-	metadataHtml = renderPageMetadata(resolved);
+	jsonLdScripts = resolved.jsonld;
+	metadataHtml = renderPageMetadata(resolved, { includeJsonLd: false });
 	siteIdentityHtml = renderSiteIdentity({ favicon: siteSettings.favicon });
 	fragmentsHtml = renderFragments(fragments, "head");
 } else {
 	// No runtime (EmDash not initialized) — still render base SEO
 	const baseContributions: PageMetadataContribution[] = generateBaseSeoContributions(page);
 	const resolved = resolvePageMetadata(baseContributions);
-	metadataHtml = renderPageMetadata(resolved);
+	jsonLdScripts = resolved.jsonld;
+	metadataHtml = renderPageMetadata(resolved, { includeJsonLd: false });
+}
+
+if (Astro.csp && jsonLdScripts.length > 0) {
+	await Promise.all(
+		jsonLdScripts.map(async ({ json }) => {
+			Astro.csp?.insertScriptHash(await createSha256CspHash(json));
+		}),
+	);
 }
 ---
 
 <Fragment set:html={metadataHtml} />
+{
+	jsonLdScripts.map(({ json }) => <JsonLdScript json={json} />)
+}
 <Fragment set:html={siteIdentityHtml} />
 <Fragment set:html={fragmentsHtml} />

package/src/components/EmDashImage.astro

@@ -158,15 +158,12 @@ if (img) {
 	}
 }
 
-// Build placeholder background style
+// Build placeholder background style. Prefer the first-class MediaValue fields;
+// fall back to `meta` for snapshots stored before LQIP was promoted off `meta`.
 const blurhash =
-	typeof image === "object"
-		? (image?.meta?.blurhash as string | undefined)
-		: undefined;
+	img?.blurhash ?? (img?.meta?.blurhash as string | undefined);
 const dominantColor =
-	typeof image === "object"
-		? (image?.meta?.dominantColor as string | undefined)
-		: undefined;
+	img?.dominantColor ?? (img?.meta?.dominantColor as string | undefined);
 
 let placeholderStyle = "";
 if (blurhash) {

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/components/JsonLdScript.astro

@@ -0,0 +1,9 @@
+---
+interface Props {
+	json: string;
+}
+
+const { json } = Astro.props;
+---
+
+<script type="application/ld+json" set:html={json}></script>

package/src/database/migrations/036_i18n_menus_and_taxonomies.ts

@@ -199,6 +199,15 @@ async function rebuildTaxonomies(db: Kysely<unknown>, defaultLocale: string): Pr
 		.on("taxonomies")
 		.column("translation_group")
 		.execute();
+	// Dropping the old table dropped idx_taxonomies_parent (from 015); recreate
+	// it here for parity with rebuildMenuItems/rebuildContentTaxonomies. Existing
+	// installs recover it via migration 047.
+	await db.schema
+		.createIndex("idx_taxonomies_parent")
+		.ifNotExists()
+		.on("taxonomies")
+		.column("parent_id")
+		.execute();
 }
 
 async function rebuildTaxonomyDefs(db: Kysely<unknown>, defaultLocale: string): Promise<void> {
@@ -569,6 +578,13 @@ async function rebuildTaxonomiesDown(db: Kysely<unknown>): Promise<void> {
 	await db.schema.dropTable("taxonomies").execute();
 	await sql`ALTER TABLE taxonomies_old RENAME TO taxonomies`.execute(db);
 	await db.schema.createIndex("idx_taxonomies_name").on("taxonomies").column("name").execute();
+	// Restore the pre-036 (migration 015) parent index so the rollback is faithful.
+	await db.schema
+		.createIndex("idx_taxonomies_parent")
+		.ifNotExists()
+		.on("taxonomies")
+		.column("parent_id")
+		.execute();
 }
 
 async function rebuildTaxonomyDefsDown(db: Kysely<unknown>): Promise<void> {