emdash 1.0.1 → 1.2.0

package/src/mcp/server.ts

@@ -1015,7 +1015,11 @@ export function createMcpServer(
 				orderBy: z
 					.string()
 					.optional()
-					.describe("Field to sort by (e.g. 'created_at', 'updated_at')"),
+					.describe(
+						"Field to sort by: 'createdAt' (default), 'updatedAt', 'publishedAt', 'scheduledAt', " +
+							"'slug', 'status', 'locale', or a field slug that is indexed or set as the " +
+							"collection's titleField or dateField",
+					),
 				order: z.enum(["asc", "desc"]).optional().describe("Sort direction (default 'desc')"),
 				locale: z
 					.string()
@@ -2015,8 +2019,10 @@ export function createMcpServer(
 			description:
 				"Create a new byline (author/contributor credit). The slug must be unique " +
 				"and contain only lowercase letters, digits, and hyphens. Link the byline " +
-				"to a CMS user via userId, or leave it as a standalone guest credit. The " +
-				"returned id can then be passed to content_create/content_update bylines.",
+				"to a CMS user via userId, or leave it as a standalone guest credit. A " +
+				"translation created with translationOf keeps the source's userId unless " +
+				"you pass one; pass null to leave it unlinked. The returned id can then be " +
+				"passed to content_create/content_update bylines.",
 			inputSchema: z.object({ ...bylineCreateBody.shape }),
 			annotations: { destructiveHint: false },
 		},
@@ -3690,7 +3696,9 @@ export function createMcpServer(
 			title: "Update Site Settings",
 			description:
 				"Update one or more site-wide settings. This is a partial update: only " +
-				"the fields provided are changed; omitted fields are left as-is. Returns " +
+				"the fields provided are changed; omitted fields are left as-is, including " +
+				"fields inside `seo` and `social`. Send an empty string to clear a text " +
+				"field. Returns " +
 				"the full settings object after the update. To set a media reference " +
 				"(logo, favicon, seo.defaultOgImage), pass an object with `mediaId` " +
 				"(and optional `alt`) — the media item must already exist (use " +

package/src/media/image-endpoint.ts

@@ -34,6 +34,17 @@ export const DEFAULT_TRANSFORM_QUALITY = 85;
 /** Upper bound for a requested dimension; caps the work a single request asks for. */
 export const MAX_TRANSFORM_DIMENSION = 4000;
 
+/** Weak prefix on an ETag, stripped for weak comparison per RFC 7232. */
+const WEAK_ETAG_PREFIX = /^W\//;
+
+/**
+ * Strip surrounding whitespace and the weak prefix from an ETag value for
+ * weak comparison. Defined at module scope so it is not recreated per request.
+ */
+function stripWeakEtagPrefix(value: string): string {
+	return value.trim().replace(WEAK_ETAG_PREFIX, "");
+}
+
 /** A format string accepted by {@link ImageTransformOptions.format}. */
 export type ImageTransformFormat = (typeof ALLOWED_TRANSFORM_FORMATS)[number];
 
@@ -56,6 +67,90 @@ 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";
 
+/**
+ * Format a Date as an HTTP-date (RFC 7231).
+ */
+export function formatHttpDate(date: Date): string {
+	return date.toUTCString();
+}
+
+/**
+ * Build a weak validator from representation metadata. Weak because it is based
+ * on size and modification time rather than a content hash. Keeps the same
+ * shape for stored files and derived transforms so replacements change the tag.
+ */
+export function makeWeakEtag(size: number, lastModified?: Date, suffix?: string): string {
+	let value = String(size);
+	if (lastModified) value += `-${lastModified.getTime()}`;
+	if (suffix) value += `-${suffix}`;
+	return `W/"${value}"`;
+}
+
+/**
+ * Build a canonical fingerprint of the transform query params that affect the
+ * derived /_image bytes. Used as the suffix of a transform's weak ETag.
+ */
+export function getTransformFingerprint(params: URLSearchParams): string {
+	const parts: string[] = [];
+	const append = (name: string) => {
+		const value = params.get(name);
+		if (value !== null) parts.push(`${name}=${value}`);
+	};
+	append("w");
+	append("h");
+	append("f");
+	append("q");
+	append("fit");
+	return parts.join("&");
+}
+
+/**
+ * Check whether a request's preconditions are satisfied for the given
+ * representation. Returns true when the client already has the current version.
+ */
+export function isNotModified(
+	request: Request,
+	size: number,
+	lastModified?: Date,
+	suffix?: string,
+): boolean {
+	const etag = makeWeakEtag(size, lastModified, suffix);
+	const ifNoneMatch = request.headers.get("If-None-Match");
+	if (ifNoneMatch !== null) {
+		if (ifNoneMatch.trim() === "*") return true;
+		// If-None-Match uses weak comparison: "W/" prefixes are ignored.
+		const requestedTags = ifNoneMatch.split(",").map(stripWeakEtagPrefix);
+		return requestedTags.includes(stripWeakEtagPrefix(etag));
+	}
+	const ifModifiedSince = request.headers.get("If-Modified-Since");
+	if (ifModifiedSince !== null && lastModified) {
+		const since = Date.parse(ifModifiedSince);
+		if (!Number.isNaN(since)) {
+			// HTTP-date has one-second precision; round the stored time down so
+			// a Last-Modified header replayed as If-Modified-Since always matches.
+			return Math.floor(lastModified.getTime() / 1000) * 1000 <= since;
+		}
+	}
+	return false;
+}
+
+/**
+ * Headers that make a mutable representation conditionally cacheable.
+ */
+export function validatorHeaders(
+	size: number,
+	lastModified?: Date,
+	suffix?: string,
+): Record<string, string> {
+	const headers: Record<string, string> = {
+		ETag: makeWeakEtag(size, lastModified, suffix),
+	};
+	if (lastModified) {
+		headers["Last-Modified"] = formatHttpDate(lastModified);
+	}
+	return headers;
+}
+
 /**
  * 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 +172,11 @@ const SAFE_INLINE_IMAGE_TYPES = new Set([
  * inline raster allowlist (so a stored SVG can't run scripts in the site
  * origin). Transformed output is always generated raster and doesn't need this.
  */
-export function originalMediaHeaders(contentType: string): Record<string, string> {
+export function originalMediaHeaders(
+	contentType: string,
+	size?: number,
+	lastModified?: Date,
+): Record<string, string> {
 	return {
 		"Content-Type": contentType,
 		"Cache-Control": MUTABLE_MEDIA_CACHE_CONTROL,
@@ -85,6 +184,7 @@ export function originalMediaHeaders(contentType: string): Record<string, string
 		"Content-Security-Policy":
 			"sandbox; default-src 'none'; img-src 'self'; style-src 'unsafe-inline'",
 		"Content-Disposition": SAFE_INLINE_IMAGE_TYPES.has(contentType) ? "inline" : "attachment",
+		...(size !== undefined ? validatorHeaders(size, lastModified) : {}),
 	};
 }
 

package/src/media/mime.ts

@@ -1,3 +1,5 @@
+import * as path from "node:path";
+
 export function normalizeMime(mime: string): string {
 	return mime.split(";")[0].trim().toLowerCase();
 }
@@ -16,6 +18,24 @@ export function matchesMimeAllowlist(mime: string, allowList: readonly string[])
 	return false;
 }
 
+const UNKNOWN_UPLOAD_TYPES = new Set(["", "application/octet-stream"]);
+
+/**
+ * Resolve the MIME type for an uploaded file.
+ *
+ * Browsers that don't recognise an extension (e.g. `.jxl`) often report an
+ * empty or generic `application/octet-stream` type. In those cases fall back to
+ * the extension map so server-side allowlist checks can still identify allowed
+ * formats such as `image/jxl`.
+ */
+export function resolveUploadMimeType(filename: string, fileType: string): string {
+	const normalized = normalizeMime(fileType);
+	if (normalized && !UNKNOWN_UPLOAD_TYPES.has(normalized)) {
+		return normalized;
+	}
+	return EXTENSION_TO_MIME[path.extname(filename).toLowerCase()] ?? "";
+}
+
 export const EXTENSION_TO_MIME: Readonly<Record<string, string>> = {
 	".pdf": "application/pdf",
 	".png": "image/png",
@@ -24,6 +44,7 @@ export const EXTENSION_TO_MIME: Readonly<Record<string, string>> = {
 	".gif": "image/gif",
 	".webp": "image/webp",
 	".avif": "image/avif",
+	".jxl": "image/jxl",
 	".svg": "image/svg+xml",
 	".mp3": "audio/mpeg",
 	".wav": "audio/wav",

package/src/media/responsive.ts

@@ -18,12 +18,19 @@ const ABSOLUTE_HTTP_URL = /^https?:\/\//i;
 /**
  * Pick the srcset widths to generate for an image rendered at `maxWidth`.
  * Includes breakpoints up to 2x (retina) plus the rendered width itself, so the
- * browser always has an exact-fit candidate.
+ * browser always has an exact-fit candidate. A known `originalWidth` below 2x
+ * lowers that limit, so the source is never upscaled for a high-density
+ * candidate. The limit itself is a candidate up to the largest breakpoint, so
+ * images narrower than the first breakpoint still get one.
  */
-export function responsiveWidths(maxWidth: number): number[] {
-	const cap = maxWidth * 2;
+export function responsiveWidths(maxWidth: number, originalWidth?: number): number[] {
+	const width = Math.round(maxWidth);
+	if (!(width >= 1)) return [];
+	const original = Math.round(originalWidth ?? 0);
+	const cap = original >= 1 && original < width * 2 ? original : width * 2;
 	const widths = new Set(RESPONSIVE_BREAKPOINTS.filter((w) => w <= cap));
-	widths.add(maxWidth);
+	widths.add(width);
+	if (cap <= Math.max(...RESPONSIVE_BREAKPOINTS)) widths.add(cap);
 	return [...widths].toSorted((a, b) => a - b);
 }
 
@@ -120,9 +127,9 @@ export interface ResponsiveImage {
  */
 export async function buildResponsiveImage(
 	getImage: GetImage,
-	opts: { src: string; width?: number; height?: number },
+	opts: { src: string; width?: number; height?: number; originalWidth?: number },
 ): Promise<ResponsiveImage | null> {
-	const { src, width, height } = opts;
+	const { src, width, height, originalWidth } = opts;
 	if (!src || !width || !height) return null;
 	if (!ABSOLUTE_HTTP_URL.test(src)) return null;
 	try {
@@ -131,7 +138,7 @@ export async function buildResponsiveImage(
 			src,
 			width,
 			height,
-			widths: responsiveWidths(width),
+			widths: responsiveWidths(width, originalWidth),
 			sizes,
 		});
 		// Passthrough: the service returned the source unchanged (unauthorized

package/src/media/usage/extractor.ts

@@ -1,3 +1,4 @@
+import { isPortableTextVideoBlock } from "../../content/converters/video.js";
 import { normalizeMime } from "../mime.js";
 import { INTERNAL_MEDIA_PREFIX } from "../normalize.js";
 import type {
@@ -141,6 +142,20 @@ function extractPortableTextOccurrences(
 				fieldSlug,
 				`${pathPrefix}[${blockIndex}]`,
 				block.asset,
+				"image",
+			);
+			continue;
+		}
+
+		// A plugin's own `video` block may hold a reference that isn't media.
+		if (isPortableTextVideoBlock(block)) {
+			addPortableTextAssetOccurrence(
+				occurrences,
+				seen,
+				fieldSlug,
+				`${pathPrefix}[${blockIndex}]`,
+				block.asset,
+				"video",
 			);
 			continue;
 		}
@@ -155,6 +170,7 @@ function extractPortableTextOccurrences(
 					fieldSlug,
 					`${pathPrefix}[${blockIndex}].images[${imageIndex}]`,
 					image.asset,
+					"image",
 				);
 			}
 		}
@@ -231,6 +247,7 @@ function addPortableTextAssetOccurrence(
 	fieldSlug: string,
 	pathPrefix: string,
 	asset: unknown,
+	kind: "image" | "video",
 ): void {
 	if (!isRecord(asset)) return;
 
@@ -241,12 +258,12 @@ function addPortableTextAssetOccurrence(
 	addRefOccurrence(occurrences, seen, {
 		fieldSlug,
 		fieldPath: `${pathPrefix}.asset.${ref.key}`,
-		referenceType: "portable_text_image",
+		referenceType: kind === "video" ? "portable_text_video" : "portable_text_image",
 		ref: buildMediaRef({
 			id: ref.id,
 			provider,
 			mimeType: normalizeMimeValue(asset.mimeType),
-			fallbackKind: "image",
+			fallbackKind: kind,
 		}),
 	});
 }

package/src/media/usage/types.ts

@@ -13,7 +13,11 @@ export type MediaKind =
 	| "text"
 	| "other";
 
-export type MediaUsageReferenceType = "image_field" | "file_field" | "portable_text_image";
+export type MediaUsageReferenceType =
+	| "image_field"
+	| "file_field"
+	| "portable_text_image"
+	| "portable_text_video";
 
 export interface MediaUsageExtractionSubField {
 	slug: string;

package/src/menus/index.ts

@@ -81,38 +81,42 @@ export async function getMenuWithDb(
 ): Promise<Menu | null> {
 	const chain = resolveLocaleChain(options.locale);
 
-	const selectMenu = () => db.selectFrom("_emdash_menus").selectAll().where("name", "=", name);
-
-	let menuRow: Awaited<ReturnType<ReturnType<typeof selectMenu>["executeTakeFirst"]>>;
-	if (chain.length === 0) {
-		menuRow = await selectMenu().orderBy("locale", "asc").executeTakeFirst();
-	} else {
-		menuRow = undefined;
-		for (const locale of chain) {
-			menuRow = await selectMenu().where("locale", "=", locale).executeTakeFirst();
-			if (menuRow) break;
-		}
-	}
-
+	let query = db
+		.selectFrom("_emdash_menus as m")
+		.leftJoin("_emdash_menu_items as i", "i.menu_id", "m.id")
+		.selectAll("i")
+		.select([
+			"m.id as m_id",
+			"m.name as m_name",
+			"m.label as m_label",
+			"m.locale as m_locale",
+			"m.translation_group as m_translation_group",
+		])
+		.where("m.name", "=", name)
+		.orderBy("i.sort_order", "asc");
+	if (chain.length > 0) query = query.where("m.locale", "in", chain);
+	const rows = await query.execute();
+
+	const locales = new Set(rows.map((row) => row.m_locale));
+	const locale =
+		chain.length === 0 ? [...locales].toSorted()[0] : chain.find((l) => locales.has(l));
+	const menuRow = rows.find((row) => row.m_locale === locale);
 	if (!menuRow) return null;
 
-	const itemRows = await db
-		.selectFrom("_emdash_menu_items")
-		.selectAll()
-		.$castTo<MenuItemRow>()
-		.where("menu_id", "=", menuRow.id)
-		.orderBy("sort_order", "asc")
-		.execute();
+	const menuId = menuRow.m_id;
+	const itemRows = rows.filter(
+		(row): row is typeof row & MenuItemRow => row.m_id === menuId && row.id !== null,
+	);
 
-	const items = await buildMenuTree(itemRows, db, menuRow.locale, options.trailingSlash);
+	const items = await buildMenuTree(itemRows, db, menuRow.m_locale, options.trailingSlash);
 
 	return {
-		id: menuRow.id,
-		name: menuRow.name,
-		label: menuRow.label,
+		id: menuRow.m_id,
+		name: menuRow.m_name,
+		label: menuRow.m_label,
 		items,
-		locale: menuRow.locale,
-		translationGroup: menuRow.translation_group,
+		locale: menuRow.m_locale,
+		translationGroup: menuRow.m_translation_group,
 	};
 }
 

package/src/plugin-utils.ts

@@ -64,7 +64,7 @@ export async function parseApiResponse<T>(
 	fallbackMessage = "Request failed",
 ): Promise<T> {
 	if (!response.ok) {
-		throw new Error(await getErrorMessage(response, `${fallbackMessage}: ${response.statusText}`));
+		throw new Error(await getErrorMessage(response, fallbackMessage));
 	}
 	const body: { data: T } = await response.json();
 	return body.data;

package/src/plugins/context.ts

@@ -1394,7 +1394,7 @@ const TRAILING_SLASH_RE = /\/$/;
 export interface SiteInfoOptions {
 	/** Site name from options table */
 	siteName?: string;
-	/** Site URL from options table or Astro config */
+	/** Site URL, resolved by the runtime in the same order as links in emails */
 	siteUrl?: string;
 	/** Site locale from options table */
 	locale?: string;
@@ -1403,12 +1403,8 @@ export interface SiteInfoOptions {
 }
 
 /**
- * Create site info from config and settings.
- *
- * Resolution order for URL:
- * 1. options table (emdash:site_url)
- * 2. Astro `site` config
- * 3. fallback to empty string
+ * Create site info from config and settings. A missing URL becomes an
+ * empty string.
  */
 export function createSiteInfo(options: SiteInfoOptions): SiteInfo {
 	return {

package/src/plugins/hooks.ts

@@ -22,6 +22,7 @@ import type {
 	PluginContext,
 	ActorInfo,
 	ContentHookEvent,
+	ContentSaveHookDetails,
 	ContentDeleteEvent,
 	ContentStateChangeEvent,
 	MediaUploadEvent,
@@ -185,6 +186,11 @@ export function getActiveContentSaveHookName(): ContentSaveHookName | undefined
 	return contentSaveHookContext.getStore();
 }
 
+function assignSaveHookDetails(event: ContentHookEvent, details: ContentSaveHookDetails): void {
+	if (details.locale !== undefined) event.locale = details.locale;
+	if (details.translationOf !== undefined) event.translationOf = details.translationOf;
+}
+
 /**
  * Hook pipeline for executing hooks in order
  */
@@ -558,6 +564,7 @@ export class HookPipeline {
 		isNew: boolean,
 		id?: string,
 		actor?: ActorInfo,
+		details: ContentSaveHookDetails = {},
 	): Promise<{
 		content: Record<string, unknown>;
 		results: HookResult<Record<string, unknown>>[];
@@ -575,6 +582,7 @@ export class HookPipeline {
 			};
 			if (id !== undefined) event.id = id;
 			if (actor !== undefined) event.actor = { ...actor };
+			assignSaveHookDetails(event, details);
 			const ctx = this.getContext(hook.pluginId);
 			const start = Date.now();
 
@@ -618,6 +626,7 @@ export class HookPipeline {
 		isNew: boolean,
 		actor?: ActorInfo,
 		excludePluginId?: string,
+		details: ContentSaveHookDetails = {},
 	): Promise<HookResult<void>[]> {
 		const hooks = this.getTypedHooks("content:afterSave");
 		const results: HookResult<void>[] = [];
@@ -627,6 +636,7 @@ export class HookPipeline {
 			const { handler } = hook;
 			const event: ContentHookEvent = { content, collection, isNew };
 			if (actor !== undefined) event.actor = { ...actor };
+			assignSaveHookDetails(event, details);
 			const ctx = this.getContext(hook.pluginId);
 			const start = Date.now();
 
@@ -1539,7 +1549,7 @@ export interface ExclusiveHookResolutionOptions {
 }
 
 /** Options table key prefix for exclusive hook selections */
-const EXCLUSIVE_HOOK_KEY_PREFIX = "emdash:exclusive_hook:";
+export const EXCLUSIVE_HOOK_KEY_PREFIX = "emdash:exclusive_hook:";
 
 /**
  * Resolve exclusive hook selections.

package/src/plugins/http-route-dispatch.ts

@@ -131,7 +131,11 @@ export async function dispatchPluginApiRequest({
 				? "Plugin route error"
 				: (result.error?.message ?? "Plugin route error");
 		const status = (result as { status?: number }).status ?? (code === "NOT_FOUND" ? 404 : 400);
-		return apiError(code, message, status);
+		const details =
+			code !== "INTERNAL_ERROR" && result.error && "details" in result.error
+				? result.error.details
+				: undefined;
+		return apiError(code, message, status, isRecord(details) ? details : undefined);
 	}
 
 	let response: Response;

package/src/plugins/manager.ts

@@ -27,6 +27,7 @@ import {
 import { PluginRouteRegistry, type RouteResult, type InvokeRouteOptions } from "./routes.js";
 import type {
 	ActorInfo,
+	ContentSaveHookDetails,
 	PluginDefinition,
 	ResolvedPlugin,
 	PluginStorageConfig,
@@ -308,12 +309,13 @@ export class PluginManager {
 		isNew: boolean,
 		id?: string,
 		actor?: ActorInfo,
+		details?: ContentSaveHookDetails,
 	): Promise<{
 		content: Record<string, unknown>;
 		results: HookResult<Record<string, unknown>>[];
 	}> {
 		this.ensureInitialized();
-		return this.hookPipeline!.runContentBeforeSave(content, collection, isNew, id, actor);
+		return this.hookPipeline!.runContentBeforeSave(content, collection, isNew, id, actor, details);
 	}
 
 	/**
@@ -324,9 +326,17 @@ export class PluginManager {
 		collection: string,
 		isNew: boolean,
 		actor?: ActorInfo,
+		details?: ContentSaveHookDetails,
 	): Promise<HookResult<void>[]> {
 		this.ensureInitialized();
-		return this.hookPipeline!.runContentAfterSave(content, collection, isNew, actor);
+		return this.hookPipeline!.runContentAfterSave(
+			content,
+			collection,
+			isNew,
+			actor,
+			undefined,
+			details,
+		);
 	}
 
 	/**

package/src/plugins/manifest-schema.ts

@@ -237,6 +237,7 @@ const adminPageSchema = z.object({
 	path: z.string(),
 	label: z.string(),
 	icon: z.string().optional(),
+	group: z.string().trim().min(1).max(100).optional(),
 });
 
 const dashboardWidgetSchema = z.object({

package/src/plugins/route-error.ts

@@ -55,3 +55,17 @@ export class PluginRouteError extends Error {
 		return new PluginRouteError("INTERNAL_ERROR", message, 500);
 	}
 }
+
+/**
+ * Check whether a thrown value is a PluginRouteError.
+ *
+ * Also matches on shape, not just `instanceof`: under `astro dev`, Vite can load a
+ * plugin's `emdash` import as a separate module instance, so the error the plugin
+ * throws comes from a different copy of this class.
+ */
+export function isPluginRouteError(error: unknown): error is PluginRouteError {
+	if (error instanceof PluginRouteError) return true;
+	if (!(error instanceof Error) || error.name !== "PluginRouteError") return false;
+	const { code, status } = error as Partial<PluginRouteError>;
+	return typeof code === "string" && typeof status === "number";
+}

package/src/plugins/routes.ts

@@ -20,7 +20,7 @@ import { z } from "zod";
 import { SiteWriteBlockedError } from "../transfer/fence.js";
 import { PluginContextFactory, type PluginContextFactoryOptions } from "./context.js";
 import { extractRequestMeta } from "./request-meta.js";
-import { PluginRouteError } from "./route-error.js";
+import { isPluginRouteError, PluginRouteError } from "./route-error.js";
 import { parseDeclaredPluginRouteInput } from "./route-wire.js";
 import type { ResolvedPlugin, RouteContext, PluginRoute, UserInfo } from "./types.js";
 
@@ -293,7 +293,7 @@ export class PluginRouteHandler {
 				};
 			}
 			// Handle known error types
-			if (error instanceof PluginRouteError) {
+			if (isPluginRouteError(error)) {
 				return {
 					success: false,
 					error: {

package/src/plugins/state.ts

@@ -208,6 +208,42 @@ export class PluginStateRepository {
 		return (await this.get(pluginId))!;
 	}
 
+	/**
+	 * Insert an active state row unless the plugin already has one.
+	 *
+	 * Returns true only for the caller whose insert created the row, so
+	 * concurrent callers agree on a single owner for one-time setup.
+	 */
+	async createActiveIfAbsent(
+		pluginId: string,
+		version: string,
+		source: PluginSource,
+	): Promise<boolean> {
+		const now = new Date().toISOString();
+		const inserted = await this.db
+			.insertInto("_plugin_state")
+			.values({
+				plugin_id: pluginId,
+				status: "active",
+				version,
+				installed_at: now,
+				activated_at: now,
+				deactivated_at: null,
+				data: null,
+				source,
+				marketplace_version: null,
+				display_name: null,
+				description: null,
+				registry_publisher_did: null,
+				registry_slug: null,
+				mcp_tools_consent: null,
+			})
+			.onConflict((oc) => oc.column("plugin_id").doNothing())
+			.returning("plugin_id")
+			.executeTakeFirst();
+		return inserted !== undefined;
+	}
+
 	async restoreIfVersion(expectedVersion: string, state: PluginState): Promise<boolean> {
 		const result = await this.db
 			.updateTable("_plugin_state")

package/src/plugins/types.ts

@@ -1421,6 +1421,22 @@ export interface ContentHookEvent {
 	 * who made the change.
 	 */
 	actor?: ActorInfo;
+	/**
+	 * Locale of the entry being saved: the resolved target locale on a create,
+	 * the stored entry's locale on an update.
+	 */
+	locale?: string;
+	/**
+	 * ID of the source entry when a create comes from the translation flow.
+	 * Absent on updates and on creates that start a new translation group.
+	 */
+	translationOf?: string;
+}
+
+/** Locale details a save passes to its `content:beforeSave` and `content:afterSave` hooks. */
+export interface ContentSaveHookDetails {
+	locale?: string;
+	translationOf?: string;
 }
 
 /**
@@ -1953,6 +1969,12 @@ export interface PluginAdminPage {
 	path: string;
 	label: string;
 	icon?: string;
+	/**
+	 * Admin sidebar folder. Pages sharing a group with a collection shown in
+	 * the sidebar join that folder; pages with any other group share a folder
+	 * with that label in the Plugins section, across plugins.
+	 */
+	group?: string;
 }
 
 /**