emdash 0.36.0 → 0.38.0

package/src/mcp/server.ts

@@ -21,8 +21,10 @@ import {
 	contentBylineInputSchema,
 	contentSeoInput,
 	createCollectionBody,
+	createTaxonomyDefBody,
 	updateCollectionBody,
 	updateFieldBody,
+	updateTaxonomyDefBody,
 } from "#api/schemas.js";
 
 import type { MediaUsageRepairRequest } from "../api/schemas/media-usage.js";
@@ -37,8 +39,34 @@ import { decodeBase64, encodeBase64 } from "../utils/base64.js";
 const COLLECTION_SLUG_PATTERN = /^[a-z][a-z0-9_]*$/;
 /** http(s) scheme matcher used by `settings_update` URL validation. */
 const HTTP_SCHEME_PATTERN = /^https?:\/\//i;
+/**
+ * Shared wording for the `_rev` parameter on write tools. Agents only see the
+ * tool schema, so the retry protocol is stated here.
+ */
+const REV_PARAM_DESCRIPTION =
+	"Revision token proving you have read the current item. Call content_get " +
+	"first and pass back the _rev it returns. If this call fails with CONFLICT " +
+	"the item changed in the meantime: call content_get again and retry with " +
+	"the new token.";
+
+/**
+ * Replaces Zod's "expected string, received undefined" for a caller that never
+ * read the schema, so the message says where the token comes from.
+ */
+const REV_MISSING_ERROR =
+	"_rev is required: call content_get for this item and pass back the _rev it returns.";
+
 const TAXONOMY_CURSOR_VERSION = 2;
 const MAX_TAXONOMY_CURSOR_LENGTH = 2048;
+const contentDateTimeInputSchema = z.iso
+	.datetime({ offset: true, message: "must be an ISO 8601 datetime" })
+	.or(
+		z.iso.datetime({
+			offset: true,
+			precision: -1,
+			message: "must be an ISO 8601 datetime",
+		}),
+	);
 
 // ---------------------------------------------------------------------------
 // Shared schemas — kept in sync with `api/schemas/settings.ts` (which the
@@ -138,6 +166,9 @@ const schemaUpdateCollectionToolSchema = z.object({
 	hasSeo: updateCollectionBody.shape.hasSeo.describe(
 		"Whether the collection supports SEO metadata",
 	),
+	group: updateCollectionBody.shape.group.describe(
+		"Admin sidebar folder shared with other collections of the same group; pass null to move the collection back inline",
+	),
 	commentsEnabled: updateCollectionBody.shape.commentsEnabled.describe(
 		"Whether comments are enabled for this collection",
 	),
@@ -150,6 +181,15 @@ const schemaUpdateCollectionToolSchema = z.object({
 	commentsAutoApproveUsers: updateCollectionBody.shape.commentsAutoApproveUsers.describe(
 		"Whether comments from authenticated users are automatically approved",
 	),
+	editLocking: updateCollectionBody.shape.editLocking.describe(
+		"Whether opening an entry takes an edit lock that refuses other editors' writes",
+	),
+	titleField: updateCollectionBody.shape.titleField.describe(
+		"Field slug to use as the Title column in admin lists; pass null to fall back to the default",
+	),
+	dateField: updateCollectionBody.shape.dateField.describe(
+		"Datetime field slug to use as the Date column in admin lists; pass null to fall back to the default",
+	),
 });
 
 const schemaUpdateFieldToolSchema = z.object({
@@ -617,6 +657,13 @@ function extractContentId(data: unknown): string | undefined {
 	return typeof item?.id === "string" ? item.id : undefined;
 }
 
+/** Extract the `_rev` token from a content handler response. */
+function extractContentRev(data: unknown): string | undefined {
+	if (!data || typeof data !== "object") return undefined;
+	const rev = (data as Record<string, unknown>)._rev;
+	return typeof rev === "string" ? rev : undefined;
+}
+
 // ---------------------------------------------------------------------------
 // Server factory
 // ---------------------------------------------------------------------------
@@ -827,8 +874,9 @@ export function createMcpServer(
 			title: "Get Content",
 			description:
 				"Get a single content item by its ID or slug. Returns the full content data " +
-				"including all field values, metadata, and a _rev token for optimistic " +
-				"concurrency (pass _rev back when updating to detect conflicts).",
+				"including all field values, metadata, and a _rev token. content_update, " +
+				"content_publish, content_unpublish and content_discard_draft require that " +
+				"token, so read the item here before calling them.",
 			inputSchema: z.object({
 				collection: z.string().describe("Collection slug (e.g. 'posts', 'pages')"),
 				id: z.string().describe("Content item ID (ULID) or slug"),
@@ -930,7 +978,8 @@ export function createMcpServer(
 		async (args, extra) => {
 			requireScope(extra, "content:write");
 			requireRole(extra, Role.CONTRIBUTOR);
-			const { emdash, userId } = getExtra(extra);
+			const { emdash, userId, userRole } = getExtra(extra);
+			const actor = { id: userId, role: userRole };
 
 			// Creating a translation requires edit permission on the source item
 			if (args.translationOf) {
@@ -948,7 +997,7 @@ export function createMcpServer(
 
 			// Publishing requires publish permission — create as draft then publish
 			if (args.status === "published") {
-				const user = { id: userId, role: getExtra(extra).userRole };
+				const user = { id: userId, role: userRole };
 				if (!hasPermission(user, "content:publish_own")) {
 					throw new EmDashAuthError(
 						"Insufficient permissions: publishing requires content:publish_own",
@@ -963,6 +1012,7 @@ export function createMcpServer(
 					translationOf: args.translationOf,
 					bylines: args.bylines,
 					taxonomies: args.taxonomies,
+					actor,
 				});
 				if (!result.success) return unwrap(result);
 				const itemId = extractContentId(result.data);
@@ -981,6 +1031,7 @@ export function createMcpServer(
 					translationOf: args.translationOf,
 					bylines: args.bylines,
 					taxonomies: args.taxonomies,
+					actor,
 				}),
 			);
 		},
@@ -995,9 +1046,12 @@ export function createMcpServer(
 				"in the 'data' object — unspecified fields are left unchanged. Rich text " +
 				"(portableText) fields accept a Markdown string (recommended, converted " +
 				"automatically); use a Portable Text JSON array only for complex content " +
-				"Markdown can't express (custom blocks, embeds). Pass the " +
-				"_rev token from content_get to enable optimistic concurrency checking " +
-				"(the update fails if the item was modified since you read it). " +
+				"Markdown can't express (custom blocks, embeds). Requires the _rev " +
+				"token from content_get, so read the item before updating it: the " +
+				"update fails if the item changed since that read. When status is not " +
+				"set, a change to a published item is staged as a draft, so the " +
+				"response shows the new values while the live version keeps the old " +
+				"ones until content_publish. " +
 				"`seo` and `bylines` are persisted alongside the field updates in a " +
 				"single transaction. `publishedAt` requires the content:publish_any " +
 				"permission and is useful for migrations or correcting historical dates.",
@@ -1043,22 +1097,19 @@ export function createMcpServer(
 					.describe(
 						"Replace taxonomy term assignments as { taxonomyName: [termSlug, ...] }. Term slugs are resolved in the entry's locale. Only named taxonomies are touched; other taxonomies are left unchanged. Pass an empty array to clear a taxonomy.",
 					),
-				publishedAt: z.iso
-					.datetime({ offset: true, message: "must be an ISO 8601 datetime" })
+				publishedAt: contentDateTimeInputSchema
 					.nullish()
 					.describe(
 						"Override the publication timestamp (ISO 8601). Requires content:publish_any permission. Pass null to clear. Useful for content migrations.",
 					),
-				_rev: z
-					.string()
-					.optional()
-					.describe("Revision token from content_get for conflict detection"),
+				_rev: z.string({ error: REV_MISSING_ERROR }).describe(REV_PARAM_DESCRIPTION),
 			}),
 		},
 		async (args, extra) => {
 			requireScope(extra, "content:write");
 			requireRole(extra, Role.AUTHOR);
 			const { emdash, userId, userRole } = getExtra(extra);
+			const actor = { id: userId, role: userRole };
 
 			// Fetch item to check ownership
 			const existing = await emdash.handleContentGet(args.collection, args.id, args.locale);
@@ -1090,6 +1141,7 @@ export function createMcpServer(
 			// Status transitions route through dedicated handlers for proper revision management
 			if (args.status === "published") {
 				requireOwnership(extra, ownerId, "content:publish_own", "content:publish_any");
+				let rev: string | undefined = args._rev;
 				if (
 					args.data ||
 					args.slug ||
@@ -1101,7 +1153,7 @@ export function createMcpServer(
 					const updateResult = await emdash.handleContentUpdate(args.collection, resolvedId, {
 						data,
 						slug: args.slug,
-						authorId: userId,
+						actor,
 						locale: args.locale,
 						seo: args.seo,
 						bylines: args.bylines,
@@ -1110,12 +1162,16 @@ export function createMcpServer(
 						_rev: args._rev,
 					});
 					if (!updateResult.success) return unwrap(updateResult);
+					rev = extractContentRev(updateResult.data);
 				}
-				return unwrap(await emdash.handleContentPublish(args.collection, resolvedId));
+				return unwrap(
+					await emdash.handleContentPublish(args.collection, resolvedId, { _rev: rev }),
+				);
 			}
 
 			if (args.status === "draft") {
 				requireOwnership(extra, ownerId, "content:publish_own", "content:publish_any");
+				let rev: string | undefined = args._rev;
 				if (
 					args.data ||
 					args.slug ||
@@ -1127,7 +1183,7 @@ export function createMcpServer(
 					const updateResult = await emdash.handleContentUpdate(args.collection, resolvedId, {
 						data,
 						slug: args.slug,
-						authorId: userId,
+						actor,
 						locale: args.locale,
 						seo: args.seo,
 						bylines: args.bylines,
@@ -1136,15 +1192,18 @@ export function createMcpServer(
 						_rev: args._rev,
 					});
 					if (!updateResult.success) return unwrap(updateResult);
+					rev = extractContentRev(updateResult.data);
 				}
-				return unwrap(await emdash.handleContentUnpublish(args.collection, resolvedId));
+				return unwrap(
+					await emdash.handleContentUnpublish(args.collection, resolvedId, { _rev: rev }),
+				);
 			}
 
 			return unwrap(
 				await emdash.handleContentUpdate(args.collection, resolvedId, {
 					data,
 					slug: args.slug,
-					authorId: userId,
+					actor,
 					locale: args.locale,
 					seo: args.seo,
 					bylines: args.bylines,
@@ -1260,8 +1319,8 @@ export function createMcpServer(
 			inputSchema: z.object({
 				collection: z.string().describe("Collection slug"),
 				id: z.string().describe("Content item ID or slug"),
-				publishedAt: z.iso
-					.datetime({ offset: true, message: "must be an ISO 8601 datetime" })
+				_rev: z.string({ error: REV_MISSING_ERROR }).describe(REV_PARAM_DESCRIPTION),
+				publishedAt: contentDateTimeInputSchema
 					.optional()
 					.describe(
 						"Override publication timestamp (ISO 8601). Requires content:publish_any permission. Useful when importing content with original publish dates.",
@@ -1297,6 +1356,7 @@ export function createMcpServer(
 			return unwrap(
 				await emdash.handleContentPublish(args.collection, resolvedId, {
 					publishedAt: args.publishedAt,
+					_rev: args._rev,
 				}),
 			);
 		},
@@ -1308,10 +1368,11 @@ export function createMcpServer(
 			title: "Unpublish Content",
 			description:
 				"Unpublish a content item, reverting it to draft status. It will no " +
-				"longer be visible on the live site but its content is preserved.",
+				"longer be visible on the live site, but its content and publication date are preserved.",
 			inputSchema: z.object({
 				collection: z.string().describe("Collection slug"),
 				id: z.string().describe("Content item ID or slug"),
+				_rev: z.string({ error: REV_MISSING_ERROR }).describe(REV_PARAM_DESCRIPTION),
 			}),
 		},
 		async (args, extra) => {
@@ -1332,7 +1393,9 @@ export function createMcpServer(
 			);
 
 			const resolvedId = extractContentId(existing.data) ?? args.id;
-			return unwrap(await ec.handleContentUnpublish(args.collection, resolvedId));
+			return unwrap(
+				await ec.handleContentUnpublish(args.collection, resolvedId, { _rev: args._rev }),
+			);
 		},
 	);
 
@@ -1440,6 +1503,7 @@ export function createMcpServer(
 			inputSchema: z.object({
 				collection: z.string().describe("Collection slug"),
 				id: z.string().describe("Content item ID or slug"),
+				_rev: z.string({ error: REV_MISSING_ERROR }).describe(REV_PARAM_DESCRIPTION),
 			}),
 			annotations: { destructiveHint: true },
 		},
@@ -1461,7 +1525,9 @@ export function createMcpServer(
 			);
 
 			const resolvedId = extractContentId(existing.data) ?? args.id;
-			return unwrap(await ec.handleContentDiscardDraft(args.collection, resolvedId));
+			return unwrap(
+				await ec.handleContentDiscardDraft(args.collection, resolvedId, { _rev: args._rev }),
+			);
 		},
 	);
 
@@ -1821,6 +1887,12 @@ export function createMcpServer(
 				routable: createCollectionBody.shape.routable.describe(
 					"Require a slug before publishing (default: true)",
 				),
+				editLocking: createCollectionBody.shape.editLocking.describe(
+					"Take an edit lock when an entry is opened (default: true)",
+				),
+				group: createCollectionBody.shape.group.describe(
+					"Admin sidebar folder shared with other collections of the same group",
+				),
 			}),
 		},
 		async (args, extra) => {
@@ -1840,6 +1912,8 @@ export function createMcpServer(
 					// ['drafts', 'revisions'] when undefined; pass through verbatim.
 					supports: args.supports,
 					routable: args.routable,
+					editLocking: args.editLocking,
+					group: args.group,
 				});
 				ec.invalidateUrlPatternCache();
 				return jsonResult(collection);
@@ -1969,7 +2043,7 @@ export function createMcpServer(
 							.describe("Target collection slug for reference fields"),
 						rows: z.number().optional().describe("Number of rows for textarea"),
 					})
-					.passthrough()
+					.loose()
 					.optional()
 					.describe("Widget configuration"),
 				searchable: z
@@ -2168,7 +2242,6 @@ export function createMcpServer(
 					.optional()
 					.describe("Base64-encoded file contents. Provide exactly one of base64 / url."),
 				url: z
-					.string()
 					.url()
 					.optional()
 					.describe(
@@ -2423,6 +2496,158 @@ export function createMcpServer(
 		},
 	);
 
+	server.registerTool(
+		"taxonomy_get",
+		{
+			title: "Get Taxonomy Definition",
+			description:
+				"Get a single taxonomy definition by name. Taxonomy definitions describe " +
+				"a classification system (e.g. categories or tags), which collections " +
+				"it applies to, and whether it is hierarchical. Pass `locale` to resolve " +
+				"a specific translation; otherwise the lowest matching locale is returned.",
+			inputSchema: z.object({
+				name: z.string().describe("Taxonomy name (e.g. 'categories', 'tags')"),
+				locale: z.string().optional().describe("Locale to resolve the definition for"),
+			}),
+			annotations: { readOnlyHint: true },
+		},
+		async (args, extra) => {
+			requireScope(extra, "content:read");
+			const ec = getEmDash(extra);
+			try {
+				const { handleTaxonomyGet } = await import("../api/handlers/taxonomies.js");
+				return unwrap(await handleTaxonomyGet(ec.db, args.name, { locale: args.locale }));
+			} catch (error) {
+				return respondHandlerError(error, "TAXONOMY_GET_ERROR");
+			}
+		},
+	);
+
+	server.registerTool(
+		"taxonomy_create",
+		{
+			title: "Create Taxonomy Definition",
+			description:
+				"Create a new taxonomy definition. Definitions are per-locale; pass " +
+				"`locale` when the same taxonomy name exists in multiple translations. " +
+				"`collections` names which content types the taxonomy applies to. " +
+				"If `translationOf` is set, the new definition joins the source's " +
+				"translation group and inherits `hierarchical` and `collections` from " +
+				"the source when those fields are omitted.",
+			inputSchema: z.object({
+				name: createTaxonomyDefBody.shape.name.describe(
+					"Taxonomy name (lowercase letters, numbers, underscores)",
+				),
+				label: createTaxonomyDefBody.shape.label.describe("Display name"),
+				labelSingular: createTaxonomyDefBody.shape.labelSingular.describe(
+					"Singular form of the display name",
+				),
+				hierarchical: createTaxonomyDefBody.shape.hierarchical.describe(
+					"Whether the taxonomy supports parent/child terms (defaults to false, or inherited from translationOf)",
+				),
+				collections: createTaxonomyDefBody.shape.collections.describe(
+					"Collection slugs this taxonomy applies to (defaults to [], or inherited from translationOf)",
+				),
+				locale: z.string().optional().describe("Locale for this definition (e.g. 'fr-fr')"),
+				translationOf: z
+					.string()
+					.optional()
+					.describe("Existing taxonomy definition id to create this locale variant from"),
+			}),
+		},
+		async (args, extra) => {
+			requireScope(extra, "taxonomies:manage");
+			requireRole(extra, Role.EDITOR);
+			const ec = getEmDash(extra);
+			try {
+				const { handleTaxonomyCreate } = await import("../api/handlers/taxonomies.js");
+				return unwrap(
+					await handleTaxonomyCreate(ec.db, {
+						name: args.name,
+						label: args.label,
+						labelSingular: args.labelSingular,
+						hierarchical: args.hierarchical,
+						collections: args.collections,
+						locale: args.locale,
+						translationOf: args.translationOf,
+					}),
+				);
+			} catch (error) {
+				return respondHandlerError(error, "TAXONOMY_CREATE_ERROR");
+			}
+		},
+	);
+
+	server.registerTool(
+		"taxonomy_update",
+		{
+			title: "Update Taxonomy Definition",
+			description:
+				"Update an existing taxonomy definition. The taxonomy `name` cannot be " +
+				"changed. Pass `locale` to update a specific translation; otherwise the " +
+				"lowest matching locale is updated. Any field may be omitted to leave it " +
+				"unchanged.",
+			inputSchema: z.object({
+				name: z.string().describe("Taxonomy name to update"),
+				label: updateTaxonomyDefBody.shape.label.describe("New display name"),
+				labelSingular: updateTaxonomyDefBody.shape.labelSingular.describe(
+					"New singular display name; pass null to clear",
+				),
+				hierarchical: updateTaxonomyDefBody.shape.hierarchical.describe(
+					"Whether the taxonomy supports parent/child terms",
+				),
+				collections: updateTaxonomyDefBody.shape.collections.describe(
+					"Collection slugs this taxonomy applies to",
+				),
+				locale: z.string().optional().describe("Locale of the definition to update"),
+			}),
+		},
+		async (args, extra) => {
+			requireScope(extra, "taxonomies:manage");
+			requireRole(extra, Role.EDITOR);
+			const ec = getEmDash(extra);
+			try {
+				const { handleTaxonomyUpdate } = await import("../api/handlers/taxonomies.js");
+				return unwrap(
+					await handleTaxonomyUpdate(ec.db, args.name, {
+						label: args.label,
+						labelSingular: args.labelSingular,
+						hierarchical: args.hierarchical,
+						collections: args.collections,
+						locale: args.locale,
+					}),
+				);
+			} catch (error) {
+				return respondHandlerError(error, "TAXONOMY_UPDATE_ERROR");
+			}
+		},
+	);
+
+	server.registerTool(
+		"taxonomy_delete",
+		{
+			title: "Delete Taxonomy Definition",
+			description:
+				"Delete a taxonomy definition and all of its terms in every locale, " +
+				"along with any content assignments those terms hold. This cannot be undone.",
+			inputSchema: z.object({
+				name: z.string().describe("Taxonomy name to delete"),
+			}),
+			annotations: { destructiveHint: true },
+		},
+		async (args, extra) => {
+			requireScope(extra, "taxonomies:manage");
+			requireRole(extra, Role.EDITOR);
+			const ec = getEmDash(extra);
+			try {
+				const { handleTaxonomyDelete } = await import("../api/handlers/taxonomies.js");
+				return unwrap(await handleTaxonomyDelete(ec.db, args.name));
+			} catch (error) {
+				return respondHandlerError(error, "TAXONOMY_DELETE_ERROR");
+			}
+		},
+	);
+
 	server.registerTool(
 		"taxonomy_list_terms",
 		{
@@ -3026,10 +3251,7 @@ export function createMcpServer(
 					.describe("Favicon media reference ({ mediaId, alt? })"),
 				url: z
 					.union([
-						z
-							.string()
-							.url()
-							.refine((u) => HTTP_SCHEME_PATTERN.test(u), "URL must use http or https"),
+						z.url().refine((u) => HTTP_SCHEME_PATTERN.test(u), "URL must use http or https"),
 						z.literal(""),
 					])
 					.optional()

package/src/media/image-endpoint.ts

@@ -50,9 +50,12 @@ export interface ImageTransformOptions {
 	quality?: number;
 }
 
-/** Long-lived immutable cache -- transform output is deterministic per key+params. */
+/** Long-lived cache for content-addressed image URLs. */
 export const IMMUTABLE_IMAGE_CACHE = "public, max-age=31536000, immutable";
 
+/** Cache policy for media keys that Replace original may overwrite. */
+export const MUTABLE_MEDIA_CACHE_CONTROL = "public, max-age=0, must-revalidate";
+
 /**
  * Raster types safe to render inline. Anything else (SVG, PDF, ...) is served
  * as an attachment so it can't execute as an active document. Mirrors the
@@ -77,7 +80,7 @@ const SAFE_INLINE_IMAGE_TYPES = new Set([
 export function originalMediaHeaders(contentType: string): Record<string, string> {
 	return {
 		"Content-Type": contentType,
-		"Cache-Control": IMMUTABLE_IMAGE_CACHE,
+		"Cache-Control": MUTABLE_MEDIA_CACHE_CONTROL,
 		"X-Content-Type-Options": "nosniff",
 		"Content-Security-Policy":
 			"sandbox; default-src 'none'; img-src 'self'; style-src 'unsafe-inline'",

package/src/media/normalize.ts

@@ -15,6 +15,16 @@ import type { MediaProvider, MediaProviderItem, MediaValue } from "./types.js";
 export const INTERNAL_MEDIA_PREFIX = "/_emdash/api/media/file/";
 const URL_PATTERN = /^https?:\/\//;
 
+export function normalizeLegacyExternalMediaValue(value: MediaValue): MediaValue {
+	if (value.provider !== "external-url") return value;
+	const src = value.src ?? value.previewUrl;
+	return {
+		...value,
+		provider: "external",
+		...(src === undefined ? {} : { src }),
+	};
+}
+
 /**
  * Normalize a media field value into a consistent MediaValue shape.
  *
@@ -41,16 +51,17 @@ export async function normalizeMediaValue(
 	// Must have at least an id to be a valid media value
 	if (!("id" in value) && !("src" in value)) return null;
 
-	const provider = (typeof value.provider === "string" ? value.provider : undefined) || "local";
-	const id = typeof value.id === "string" ? value.id : "";
+	const parsed = normalizeLegacyExternalMediaValue(recordToMediaValue(value));
+	const provider = parsed.provider || "local";
+	const id = parsed.id;
 
 	// External URLs — return as-is, no server-side dimension detection
 	if (provider === "external") {
-		return recordToMediaValue(value);
+		return parsed;
 	}
 
 	// Build the base value from the input
-	const result: MediaValue = { ...recordToMediaValue(value), provider };
+	const result: MediaValue = { ...parsed, provider };
 
 	// For local media, strip `src` — it's derived at display time from storageKey
 	if (provider === "local") {

package/src/media/responsive.ts

@@ -32,6 +32,29 @@ export function responsiveSizes(width: number | undefined): string {
 	return width ? `(min-width: ${width}px) ${width}px, 100vw` : "100vw";
 }
 
+/** Column count `Gallery.astro` uses when a gallery block does not set one. */
+export const GALLERY_DEFAULT_COLUMNS = 3;
+
+/**
+ * Build the `sizes` attribute for one cell of a Portable Text gallery.
+ *
+ * Mirrors the gallery's CSS: `columns` equal cells with a `1rem` gap, and two
+ * columns at `640px` and below. Each cell is estimated against the viewport, so
+ * a gallery inside a narrower content column still gets a larger slot than it
+ * renders at; pass `sizes` to `Gallery` when the container width is known.
+ */
+export function gallerySizes(columns: number | undefined): string {
+	const count =
+		typeof columns === "number" && Number.isInteger(columns) && columns > 0
+			? columns
+			: GALLERY_DEFAULT_COLUMNS;
+	return `(max-width: 640px) ${galleryCell(2)}, ${galleryCell(count)}`;
+}
+
+function galleryCell(columns: number): string {
+	return columns === 1 ? "100vw" : `calc((100vw - ${columns - 1}rem) / ${columns})`;
+}
+
 /**
  * Make a same-origin media URL absolute so Astro's image service can optimize it.
  *

package/src/media/usage/cleanup.ts

@@ -81,14 +81,15 @@ export async function cleanupMediaUsage(db: Kysely<Database>): Promise<MediaUsag
 			);
 		}
 
-		if (canIssueStatement()) {
-			const cutoff = claim.scanBeforeAt;
-			const candidates = await repo.findMediaUsageCleanupCandidates({
-				cutoff,
-				cursor: claim.cursor,
-				limit: MEDIA_USAGE_CLEANUP_CANDIDATE_LIMIT,
-				cleanupLease: cleanupLease(leaseToken),
-			});
+		const cutoff = claim.scanBeforeAt;
+		const candidates = await repo.findMediaUsageCleanupCandidates({
+			cutoff,
+			cursor: claim.cursor,
+			limit: MEDIA_USAGE_CLEANUP_CANDIDATE_LIMIT,
+			cleanupLease: cleanupLease(leaseToken),
+			canIssueStatement,
+		});
+		if (candidates) {
 			candidateRows = candidates.length;
 			scanHasMore = candidates.length === MEDIA_USAGE_CLEANUP_CANDIDATE_LIMIT;
 

package/src/media/usage/content-refresh.ts

@@ -868,6 +868,7 @@ export async function findNonTranslatableSiblingContentIds(
 	updatedContentId: string,
 	translationGroup: string | null | undefined,
 	updatedData: Record<string, unknown> | undefined,
+	options: { absentAsCleared?: boolean } = {},
 ): Promise<string[]> {
 	if (!isI18nEnabled() || !updatedData || !translationGroup) return [];
 
@@ -887,7 +888,7 @@ export async function findNonTranslatableSiblingContentIds(
 		.execute();
 
 	const touchedNonTranslatableSlugs = fields
-		.filter((field) => field.slug in updatedData)
+		.filter((field) => options.absentAsCleared || field.slug in updatedData)
 		.map((field) => field.slug);
 	if (touchedNonTranslatableSlugs.length === 0) return [];