emdash 1.0.1 → 1.1.0

package/src/loader.ts

@@ -17,7 +17,7 @@ import { Kysely, type RawBuilder, sql, type Dialect } from "kysely";
 import { buildStatusCondition, isPostgres } from "./database/dialect-helpers.js";
 import { kyselyLogOption } from "./database/instrumentation.js";
 import { selectTaxonomyDefs } from "./database/repositories/taxonomy-def.js";
-import { decodeCursor, encodeCursor } from "./database/repositories/types.js";
+import { decodeCursor, encodeCursor, InvalidCursorError } from "./database/repositories/types.js";
 import { validateIdentifier } from "./database/validate.js";
 import { getI18nConfig } from "./i18n/config.js";
 import type { Database } from "./index.js";
@@ -447,10 +447,12 @@ const INCLUDE_IN_DATA: Record<string, string> = {
 const DATE_COLUMNS = new Set(["created_at", "updated_at", "published_at", "scheduled_at"]);
 
 /**
- * Hidden, symbol-keyed property on each mapped data record carrying the raw
- * DB string for every date column. Lets cursor encoders downstream reproduce
- * the loader's exact `nextCursor` format without round-tripping through
- * `new Date()`, which loses precision for stored values that aren't already
+ * Hidden, symbol-keyed property on each mapped data record carrying raw DB
+ * values: the string of every date column and, in a collection load, the
+ * primary sort column's value. Lets cursor encoders downstream reproduce the
+ * loader's exact `nextCursor` from an entry, whose `data` leaves some columns
+ * out, parses text that looks like JSON, and holds dates as `Date` objects,
+ * which lose precision for stored values that aren't already
  * ISO-with-milliseconds (e.g. `2026-01-01T00:00:00Z` becomes
  * `2026-01-01T00:00:00.000Z`).
  */
@@ -517,9 +519,10 @@ function normalizeLocalMediaValue(value: unknown): unknown {
 function mapRowToData(
 	row: Record<string, unknown>,
 	booleanFields: ReadonlySet<string>,
+	sortColumn?: string,
 ): Record<string, unknown> {
 	const data: Record<string, unknown> = {};
-	const rawDateValues: Record<string, string> = {};
+	const rawValues: Record<string, SortCursorValue> = {};
 
 	for (const [key, value] of Object.entries(row)) {
 		// Include certain system columns (mapped to camelCase where needed)
@@ -527,7 +530,7 @@ function mapRowToData(
 			// Convert date columns from ISO strings to Date objects
 			if (DATE_COLUMNS.has(key)) {
 				if (typeof value === "string") {
-					rawDateValues[key] = value;
+					rawValues[key] = value;
 					data[INCLUDE_IN_DATA[key]] = new Date(value);
 				} else {
 					data[INCLUDE_IN_DATA[key]] = null;
@@ -562,8 +565,11 @@ function mapRowToData(
 		}
 	}
 
+	if (sortColumn !== undefined && sortColumn in row) {
+		rawValues[sortColumn] = sortCursorValue(row[sortColumn]);
+	}
 	Object.defineProperty(data, CURSOR_RAW_VALUES, {
-		value: rawDateValues,
+		value: rawValues,
 		enumerable: false,
 		configurable: false,
 		writable: false,
@@ -819,26 +825,119 @@ function buildOrderByClause(
 }
 
 /**
- * Build a cursor WHERE condition for keyset pagination.
- * Uses the primary sort field + id as tiebreaker for stable ordering.
+ * Sort columns every row has a value for. Their cursors keep the plain
+ * `{ orderValue, id }` shape; any other sort column can hold NULL.
+ */
+const NON_NULL_SORT_COLUMNS = new Set(["id", "created_at", "updated_at", "status", "locale"]);
+
+type SortCursorValue = string | number | null;
+
+interface SortCursorPayload {
+	version: 1;
+	field: string;
+	value: SortCursorValue;
+}
+
+function sortCursorValue(value: unknown): SortCursorValue {
+	if (typeof value === "string" || typeof value === "number") return value;
+	if (typeof value === "boolean") return value ? 1 : 0;
+	if (value instanceof Date) return value.toISOString();
+	return null;
+}
+
+/**
+ * Encode the cursor for the page after the row whose primary sort column
+ * `field` holds `value`.
+ *
+ * @internal shared with query.ts, which re-encodes cursors from entries.
+ */
+export function encodeSortCursor(field: string, value: unknown, id: string): string {
+	const cursorValue = sortCursorValue(value);
+	if (NON_NULL_SORT_COLUMNS.has(field)) {
+		return encodeCursor(cursorValue === null ? "" : String(cursorValue), id);
+	}
+	const payload: SortCursorPayload = { version: 1, field, value: cursorValue };
+	return encodeCursor(JSON.stringify(payload), id);
+}
+
+function decodeSortCursor(cursor: string, field: string): { value: SortCursorValue; id: string } {
+	const { orderValue, id } = decodeCursor(cursor);
+	if (NON_NULL_SORT_COLUMNS.has(field)) return { value: orderValue, id };
+
+	let payload: unknown;
+	try {
+		payload = JSON.parse(orderValue);
+	} catch {
+		payload = undefined;
+	}
+	// A plain `{ orderValue, id }` cursor, which nullable columns were paged
+	// with before and which wrote a NULL as "".
+	if (payload === null || typeof payload !== "object") {
+		return { value: orderValue === "" ? null : orderValue, id };
+	}
+	const candidate = payload as Partial<SortCursorPayload>;
+	const { value } = candidate;
+	if (
+		candidate.version !== 1 ||
+		candidate.field !== field ||
+		(value !== null && typeof value !== "string" && typeof value !== "number")
+	) {
+		throw new InvalidCursorError(cursor);
+	}
+	return { value, id };
+}
+
+/**
+ * Keyset condition for the rows after `cursor`, ordered by `sort` then `id`
+ * in `direction`. The ORDER BY keeps each dialect's own NULL position, lowest
+ * on SQLite and highest on Postgres, so the condition follows it.
  *
  * Throws `InvalidCursorError` if the cursor is malformed; callers should
  * let this propagate so users see a real error rather than silently
  * falling back to the first page.
  */
+function sortCursorCondition(
+	db: Kysely<Database>,
+	cursor: string,
+	column: string,
+	direction: SortDirection,
+	sort: RawBuilder<unknown>,
+	id: RawBuilder<unknown>,
+): ReturnType<typeof sql> {
+	const { value, id: cursorId } = decodeSortCursor(cursor, column);
+	const cmp = direction === "asc" ? sql.raw(">") : sql.raw("<");
+	const nullsFirst = (direction === "asc") !== isPostgres(db);
+	if (value === null) {
+		return nullsFirst
+			? sql`(${sort} IS NOT NULL OR ${id} ${cmp} ${cursorId})`
+			: sql`(${sort} IS NULL AND ${id} ${cmp} ${cursorId})`;
+	}
+	const past = sql`${sort} ${cmp} ${value} OR (${sort} = ${value} AND ${id} ${cmp} ${cursorId})`;
+	return nullsFirst || NON_NULL_SORT_COLUMNS.has(column)
+		? sql`(${past})`
+		: sql`(${past} OR ${sort} IS NULL)`;
+}
+
+/**
+ * Build a cursor WHERE condition for keyset pagination.
+ * Uses the primary sort field + id as tiebreaker for stable ordering.
+ */
 function buildCursorCondition(
+	db: Kysely<Database>,
 	cursor: string,
 	orderBy: OrderBySpec | undefined,
 	tablePrefix?: string,
 ): ReturnType<typeof sql> {
-	const { orderValue, id: cursorId } = decodeCursor(cursor);
-	const primary = getPrimarySort(orderBy, tablePrefix);
-	const idField = tablePrefix ? `${tablePrefix}.id` : "id";
-
-	if (primary.direction === "desc") {
-		return sql`(${sql.ref(primary.field)} < ${orderValue} OR (${sql.ref(primary.field)} = ${orderValue} AND ${sql.ref(idField)} < ${cursorId}))`;
-	}
-	return sql`(${sql.ref(primary.field)} > ${orderValue} OR (${sql.ref(primary.field)} = ${orderValue} AND ${sql.ref(idField)} > ${cursorId}))`;
+	const primary = getPrimarySort(orderBy);
+	const ref = (column: string) => sql.ref(tablePrefix ? `${tablePrefix}.${column}` : column);
+	return sortCursorCondition(
+		db,
+		cursor,
+		primary.field,
+		primary.direction,
+		ref(primary.field),
+		ref("id"),
+	);
 }
 
 /** Type guard: is the where value a range object (not a string or array)? */
@@ -927,6 +1026,31 @@ function buildFieldConditions(
 	return conditions;
 }
 
+/**
+ * Pivot rows from which a term counts as large. Seeking the pivot reads every
+ * assignment of the term; walking `ec_*` in sort order reads about
+ * `collection size / term size` rows per match. The walk wins only for large
+ * terms, and the size probe reads at most this many pivot index entries.
+ *
+ * The walk estimate assumes the term's entries are spread over the sort order
+ * and the requested locale. A term clustered in time, a deep page or a narrow
+ * byline filter makes the walk read up to the whole collection; the seek would
+ * still read every assignment of the term.
+ */
+export const LARGE_TERM_ASSIGNMENTS = 200;
+
+/** A single `published_at`/`created_at` sort, which an `ec_*` index serves in order. */
+function isIndexedPivotSort(orderBy: OrderBySpec | undefined): boolean {
+	const validSortKeys = orderBy
+		? Object.keys(orderBy).filter((k) => FIELD_NAME_PATTERN.test(k))
+		: [];
+	const primary = getPrimarySort(orderBy);
+	return (
+		validSortKeys.length <= 1 &&
+		(primary.field === "published_at" || primary.field === "created_at")
+	);
+}
+
 /**
  * Resolve a taxonomy filter (`name` + one or more `slug`s, optionally scoped to
  * `locale`) to the set of `translation_group`s the pivot stores in
@@ -937,26 +1061,46 @@ function buildFieldConditions(
  * name/slug in the active locale. Resolving to explicit values (rather than an
  * `IN (subquery)`) keeps the single-term case a plain equality on the pivot
  * index, which is what gives the clean early-`LIMIT` seek.
+ *
+ * With `probeCollection`, `large` reports whether a resolved term has at least
+ * {@link LARGE_TERM_ASSIGNMENTS} pivot rows in that collection. The capped
+ * probe rides in this query; a query of its own would add a round trip to
+ * every listing.
  */
 async function resolveTermGroups(
 	db: Kysely<Database>,
 	name: string,
 	slugs: string[],
 	locale: string | undefined,
-): Promise<string[]> {
+	probeCollection?: string,
+): Promise<{ groups: string[]; large: boolean }> {
 	let query = db
 		.selectFrom("taxonomies")
 		.select("translation_group")
 		.distinct()
 		.where("name", "=", name)
-		.where("slug", "in", slugs);
+		.where("slug", "in", slugs)
+		.$if(probeCollection !== undefined, (qb) =>
+			qb.select((eb) =>
+				eb
+					.selectFrom("content_taxonomies")
+					.select(sql<number>`1`.as("hit"))
+					.where("content_taxonomies.collection", "=", probeCollection!)
+					.whereRef("content_taxonomies.taxonomy_id", "=", "taxonomies.translation_group")
+					.limit(1)
+					.offset(LARGE_TERM_ASSIGNMENTS - 1)
+					.as("large"),
+			),
+		);
 	if (locale) query = query.where("locale", "=", locale);
 	const rows = await query.execute();
 	const groups = new Set<string>();
+	let large = false;
 	for (const row of rows) {
 		if (row.translation_group) groups.add(row.translation_group);
+		if (row.large != null) large = true;
 	}
-	return [...groups];
+	return { groups: [...groups], large };
 }
 
 /** Equality (single) or `IN` (multiple) condition on a pivot group column. */
@@ -1018,18 +1162,27 @@ export interface TaxonomyPivotQueryOptions {
 	bylineGroups: string[] | null;
 	fetchLimit: number | undefined;
 	offset: number | undefined;
+	/**
+	 * SQLite only: walk `ec_*` in sort order and probe the pivot per row until
+	 * `LIMIT` rows match, instead of seeking the term and sorting its candidates.
+	 * Set it only for a single large term (see {@link LARGE_TERM_ASSIGNMENTS})
+	 * under an indexed sort with a `LIMIT`; any other shape makes the walk read
+	 * most of the collection.
+	 */
+	driveFromContent?: boolean;
 }
 
 /**
  * Build the pivot-driven taxonomy listing query (#1834).
  *
- * Drives from the term pivot and joins content translations through their
- * shared translation_group. Content columns remain authoritative for locale,
+ * Joins the term pivot to content translations through their shared
+ * translation_group. Content columns remain authoritative for locale,
  * visibility, sorting, and cursor predicates.
  *
  * Two shapes:
  * - **Indexed sort** (`published_at`/`created_at`, single sort field): the
- *   `LIMIT` lives in `picked`.
+ *   `LIMIT` lives in `picked`, which either sorts the term's candidates or,
+ *   with `driveFromContent`, walks the `ec_*` sort index and stops at `LIMIT`.
  * - **Temp-sort** (`updated_at` or any other field, or multi-field sort): no
  *   pivot sort index applies, so `picked` collects the tagged candidate set and
  *   the outer query sorts the joined rows. Bounded to tagged rows — no
@@ -1051,17 +1204,12 @@ export function buildTaxonomyPivotQuery(
 		bylineGroups,
 		fetchLimit,
 		offset,
+		driveFromContent = false,
 	} = opts;
 
 	const primary = getPrimarySort(orderBy);
-	const validSortKeys = orderBy
-		? Object.keys(orderBy).filter((k) => FIELD_NAME_PATTERN.test(k))
-		: [];
-	const singleSort = validSortKeys.length <= 1;
-	const isIndexedSort =
-		singleSort && (primary.field === "published_at" || primary.field === "created_at");
+	const isIndexedSort = isIndexedPivotSort(orderBy);
 	const dir = primary.direction === "asc" ? sql`ASC` : sql`DESC`;
-	const cmp = primary.direction === "asc" ? sql.raw(">") : sql.raw("<");
 
 	const firstGroups = groupSets[0] ?? [];
 	const restGroups = groupSets.slice(1);
@@ -1094,12 +1242,11 @@ export function buildTaxonomyPivotQuery(
 		: sql``;
 
 	const firstGroupCond = pivotGroupCondition("ct.taxonomy_id", firstGroups);
-	// A plain JOIN lets SQLite reorder the `picked` CTE. For indexed sorts
-	// (`published_at`/`created_at`) the planner can then drive from the
-	// `(deleted_at, <sort> DESC, id DESC)` index on `ec_*`, probe the pivot
-	// by primary key, and short-circuit at `LIMIT`. A `CROSS JOIN` pin would
-	// force `content_taxonomies` as the outer table and require a temp sort,
-	// producing a full nested loop over the collection on D1.
+	// `CROSS JOIN` keeps the pivot as the outer table. A plain `JOIN` lets the
+	// planner walk the `(deleted_at, <sort> DESC, id DESC)` index on `ec_*`
+	// whatever the term's size, which reads most of the collection for a
+	// small term. Postgres rejects `CROSS JOIN … ON`, so it always gets the
+	// plain `JOIN`.
 	//
 	// The temp-sort branch keeps the pin. Its `picked` collects every tagged
 	// entry with no `LIMIT`, so starting from `ec_*` can never stop early, and
@@ -1107,7 +1254,7 @@ export function buildTaxonomyPivotQuery(
 	// `deleted_at IS NULL` (a trash with many distinct deletion times): it
 	// walks the collection's `(deleted_at, status)` index and probes the pivot
 	// once per published row.
-	const pivotContentJoin = isPostgres(db) || isIndexedSort ? sql`JOIN` : sql`CROSS JOIN`;
+	const pivotContentJoin = isPostgres(db) || driveFromContent ? sql`JOIN` : sql`CROSS JOIN`;
 	const {
 		terms: termsSelect,
 		bylines: bylinesSelect,
@@ -1128,8 +1275,14 @@ export function buildTaxonomyPivotQuery(
 		let cursorClause = sql``;
 		let havingClause = sql``;
 		if (cursor) {
-			const { orderValue, id } = decodeCursor(cursor);
-			const cond = sql`(${sortval} ${cmp} ${orderValue} OR (${sortval} = ${orderValue} AND r.id ${cmp} ${id}))`;
+			const cond = sortCursorCondition(
+				db,
+				cursor,
+				primary.field,
+				primary.direction,
+				sortval,
+				sql.ref("r.id"),
+			);
 			// A GROUP BY makes `sortval` an aggregate → cursor goes in HAVING.
 			if (multiGroup) havingClause = sql`HAVING ${cond}`;
 			else cursorClause = sql`AND ${cond}`;
@@ -1164,7 +1317,7 @@ export function buildTaxonomyPivotQuery(
 
 	// Temp-sort path: seek the term via the pivot, sort the joined candidate set.
 	const orderByClause = buildOrderByClause(orderBy, "r");
-	const cursorCond = cursor ? sql`AND ${buildCursorCondition(cursor, orderBy, "r")}` : sql``;
+	const cursorCond = cursor ? sql`AND ${buildCursorCondition(db, cursor, orderBy, "r")}` : sql``;
 	const limitClause = buildPivotLimitOffset(db, fetchLimit, offset);
 	return sql<Record<string, unknown>>`
 		WITH picked AS (
@@ -1411,7 +1564,7 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 						: undefined;
 
 				// Build cursor condition if cursor is provided
-				const cursorCondition = cursor ? buildCursorCondition(cursor, orderBy) : null;
+				const cursorCondition = cursor ? buildCursorCondition(db, cursor, orderBy) : null;
 
 				// Separate taxonomy / byline filters from field filters
 				let result: { rows: Record<string, unknown>[] };
@@ -1490,14 +1643,35 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 					// below (field predicates live on `ec_*`, not the pivot). A byline
 					// filter rides along inside the pivot CTE (see the builder).
 					const groupSets: string[][] = [];
+
+					// Walking `ec_*` fills a page quickly only for one large term group
+					// under an indexed sort with a `LIMIT`. With a second taxonomy or
+					// several groups it reads far more rows than the pivot seek, so
+					// only a single slug of a single taxonomy pays for the size probe.
+					const probeCollection =
+						!isPostgres(db) &&
+						taxonomyFilters.length === 1 &&
+						taxonomyFilters[0]?.slugs.length === 1 &&
+						fetchLimit != null &&
+						isIndexedPivotSort(orderBy)
+							? type
+							: undefined;
+					let driveFromContent = false;
 					for (const taxFilter of taxonomyFilters) {
-						const groups = await resolveTermGroups(db, taxFilter.name, taxFilter.slugs, locale);
+						const { groups, large } = await resolveTermGroups(
+							db,
+							taxFilter.name,
+							taxFilter.slugs,
+							locale,
+							probeCollection,
+						);
 						// A slug that resolves to no term matches nothing; since taxonomy
 						// filters AND together, one empty set empties the whole result.
 						if (groups.length === 0) {
 							return { entries: [], cacheHint: { tags: [type] } };
 						}
 						groupSets.push(groups);
+						driveFromContent = large && groups.length === 1;
 					}
 
 					result = await buildTaxonomyPivotQuery({
@@ -1514,6 +1688,7 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 						bylineGroups: bylineFilter ? bylineFilter.groups : null,
 						fetchLimit,
 						offset,
+						driveFromContent,
 					}).execute(db);
 				} else {
 					// Taxonomy and byline filters are applied as correlated
@@ -1607,11 +1782,17 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 				const hasMore = limit ? result.rows.length > limit : false;
 				const rows = hasMore ? result.rows.slice(0, limit) : result.rows;
 
+				const primary = getPrimarySort(orderBy);
+				// Strip table prefix from field name for row lookup
+				const sortColumn = primary.field.includes(".")
+					? primary.field.split(".").pop()!
+					: primary.field;
+
 				// Map rows to entries
 				const booleanFields = parseFoldedBooleanFields(rows[0]);
 				const entries = rows.map((row) => {
 					const id = entryIdForRow(row);
-					const data = mapRowToData(row, booleanFields);
+					const data = mapRowToData(row, booleanFields, sortColumn);
 					stashFolded(data, row);
 					return {
 						id,
@@ -1629,17 +1810,7 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 				let nextCursor: string | undefined;
 				if (hasMore && rows.length > 0) {
 					const lastRow = rows.at(-1)!;
-					const primary = getPrimarySort(orderBy);
-					// Strip table prefix from field name for row lookup
-					const fieldName = primary.field.includes(".")
-						? primary.field.split(".").pop()!
-						: primary.field;
-					const lastOrderValue = lastRow[fieldName];
-					const orderStr =
-						typeof lastOrderValue === "string" || typeof lastOrderValue === "number"
-							? String(lastOrderValue)
-							: "";
-					nextCursor = encodeCursor(orderStr, String(lastRow.id));
+					nextCursor = encodeSortCursor(sortColumn, lastRow[sortColumn], String(lastRow.id));
 				}
 
 				// Collection-level cache hint uses the most recent updated_at

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/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/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/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();