diff --git a/.changeset/fix-menus-rest-shape-and-id-routes.md b/.changeset/fix-menus-rest-shape-and-id-routes.md
new file mode 100644
index 000000000..938c88515
--- /dev/null
+++ b/.changeset/fix-menus-rest-shape-and-id-routes.md
@@ -0,0 +1,13 @@
+---
+"emdash": minor
+"@emdash-cms/admin": minor
+---
+
+Fixes menu REST API consistency:
+
+- **`POST /menus/:name/items` no longer accepts unknown keys silently.** Sending `custom_url` (snake_case) or `url` used to return 201 with `custom_url: null` because Zod's default `.strip()` quietly dropped them. The schemas now use `.strict()` and return **400 `VALIDATION_ERROR`** with `Unrecognized key: "custom_url"`. The documented camelCase keys (`customUrl`, `sortOrder`, `referenceCollection`, etc.) are unchanged and persist as before. The `type` field is now validated against the canonical enum (`"custom" | "page" | "post" | "taxonomy" | "collection"`); previously any string passed.
+- **Moves per-item writes to `PUT` and `DELETE /menus/:name/items/:id` (path-style).** Every other EmDash resource (`content`, `taxonomies`, `redirects`, `sections`, `widget-areas`) addresses items by URL path; menus were the lone outlier requiring `?id=<id>` in the query string. The legacy query-string form is **removed** (it was undocumented and only used by the admin, which is updated in this PR). Callers should use `PUT /menus/:name/items/:id` / `DELETE /menus/:name/items/:id`.
+- **Menu and menu-item API responses are now camelCase**, aligning with the rest of EmDash's REST surface (`content`, `taxonomies`, `redirects`, …). `created_at` → `createdAt`, `updated_at` → `updatedAt`, `menu_id` → `menuId`, `parent_id` → `parentId`, `sort_order` → `sortOrder`, `reference_collection` → `referenceCollection`, `reference_id` → `referenceId`, `custom_url` → `customUrl`, `title_attr` → `titleAttr`, `css_classes` → `cssClasses`, `translation_group` → `translationGroup`. **Breaking** for direct REST consumers that depend on snake_case keys in the response body. The admin UI is already updated.
+- **Refactors menus to the standard repository pattern.** Adds `MenuRepository` next to `ContentRepository`, `TaxonomyRepository`, `RedirectRepository`, `MediaRepository`, `CommentRepository`. Handlers become thin orchestrators; the repository is now the single place where snake_case rows become camelCase entities.
+
+These changes do not touch any database schema or migration. Existing data is preserved.
diff --git a/packages/admin/src/components/MenuEditor.tsx b/packages/admin/src/components/MenuEditor.tsx
index 2b3cc5a97..e2f7a531e 100644
--- a/packages/admin/src/components/MenuEditor.tsx
+++ b/packages/admin/src/components/MenuEditor.tsx
@@ -241,7 +241,7 @@ export function MenuEditor() {
 		// Update sort orders
 		const reorderedItems = newItems.map((item, i) => ({
 			id: item.id,
-			parentId: item.parent_id,
+			parentId: item.parentId,
 			sortOrder: i,
 		}));
 
@@ -418,10 +418,10 @@ export function MenuEditor() {
 								<div className="font-medium">{item.label}</div>
 								<div className="text-sm text-kumo-subtle">
 									{item.type === "custom" ? (
-										item.custom_url
+										item.customUrl
 									) : (
 										<span className="inline-flex items-center rounded-full bg-kumo-brand/10 px-2 py-0.5 text-xs font-medium text-kumo-brand">
-											{item.reference_collection ?? item.type}
+											{item.referenceCollection ?? item.type}
 										</span>
 									)}
 									{item.target === "_blank" && t` (opens in new window)`}
@@ -504,7 +504,7 @@ export function MenuEditor() {
 									required
 									pattern="(https?://.+|/.*)"
 									title={t`Enter a URL (https://…) or a relative path (/…)`}
-									defaultValue={editingItem.custom_url || ""}
+									defaultValue={editingItem.customUrl || ""}
 								/>
 							)}
 							<Select
diff --git a/packages/admin/src/lib/api/menus.ts b/packages/admin/src/lib/api/menus.ts
index b137a45b9..1c8d08652 100644
--- a/packages/admin/src/lib/api/menus.ts
+++ b/packages/admin/src/lib/api/menus.ts
@@ -15,29 +15,29 @@ export interface Menu {
 	id: string;
 	name: string;
 	label: string;
-	created_at: string;
-	updated_at: string;
+	createdAt: string;
+	updatedAt: string;
 	itemCount?: number;
 	locale: string;
-	translation_group: string | null;
+	translationGroup: string | null;
 }
 
 export interface MenuItem {
 	id: string;
-	menu_id: string;
-	parent_id: string | null;
-	sort_order: number;
+	menuId: string;
+	parentId: string | null;
+	sortOrder: number;
 	type: string;
-	reference_collection: string | null;
-	reference_id: string | null;
-	custom_url: string | null;
+	referenceCollection: string | null;
+	referenceId: string | null;
+	customUrl: string | null;
 	label: string;
-	title_attr: string | null;
+	titleAttr: string | null;
 	target: string | null;
-	css_classes: string | null;
-	created_at: string;
+	cssClasses: string | null;
+	createdAt: string;
 	locale: string;
-	translation_group: string | null;
+	translationGroup: string | null;
 }
 
 export interface MenuWithItems extends Menu {
@@ -192,7 +192,7 @@ export async function updateMenuItem(
 	options: LocaleOptions = {},
 ): Promise<MenuItem> {
 	const response = await apiFetch(
-		withLocale(`${API_BASE}/menus/${menuName}/items?id=${itemId}`, options.locale),
+		withLocale(`${API_BASE}/menus/${menuName}/items/${itemId}`, options.locale),
 		{
 			method: "PUT",
 			headers: { "Content-Type": "application/json" },
@@ -211,7 +211,7 @@ export async function deleteMenuItem(
 	options: LocaleOptions = {},
 ): Promise<void> {
 	const response = await apiFetch(
-		withLocale(`${API_BASE}/menus/${menuName}/items?id=${itemId}`, options.locale),
+		withLocale(`${API_BASE}/menus/${menuName}/items/${itemId}`, options.locale),
 		{ method: "DELETE" },
 	);
 	if (!response.ok) await throwResponseError(response, i18n._(msg`Failed to delete menu item`));
diff --git a/packages/admin/tests/components/MenuEditor.test.tsx b/packages/admin/tests/components/MenuEditor.test.tsx
index 0d411cc69..ec80b131c 100644
--- a/packages/admin/tests/components/MenuEditor.test.tsx
+++ b/packages/admin/tests/components/MenuEditor.test.tsx
@@ -49,38 +49,44 @@ const defaultMenu = {
 	id: "menu1",
 	name: "main-menu",
 	label: "Main Menu",
-	created_at: "",
-	updated_at: "",
+	createdAt: "",
+	updatedAt: "",
+	locale: "en",
+	translationGroup: "menu1",
 	items: [
 		{
 			id: "1",
-			menu_id: "menu1",
-			parent_id: null,
-			sort_order: 0,
+			menuId: "menu1",
+			parentId: null,
+			sortOrder: 0,
 			type: "custom",
-			reference_collection: null,
-			reference_id: null,
-			custom_url: "/",
+			referenceCollection: null,
+			referenceId: null,
+			customUrl: "/",
 			label: "Home",
-			title_attr: null,
+			titleAttr: null,
 			target: "_self",
-			css_classes: null,
-			created_at: "",
+			cssClasses: null,
+			createdAt: "",
+			locale: "en",
+			translationGroup: "1",
 		},
 		{
 			id: "2",
-			menu_id: "menu1",
-			parent_id: null,
-			sort_order: 1,
+			menuId: "menu1",
+			parentId: null,
+			sortOrder: 1,
 			type: "custom",
-			reference_collection: null,
-			reference_id: null,
-			custom_url: "/about",
+			referenceCollection: null,
+			referenceId: null,
+			customUrl: "/about",
 			label: "About",
-			title_attr: null,
+			titleAttr: null,
 			target: "_self",
-			css_classes: null,
-			created_at: "",
+			cssClasses: null,
+			createdAt: "",
+			locale: "en",
+			translationGroup: "2",
 		},
 	],
 };
diff --git a/packages/core/src/api/handlers/menus.ts b/packages/core/src/api/handlers/menus.ts
index a53d027b7..9c3bda84e 100644
--- a/packages/core/src/api/handlers/menus.ts
+++ b/packages/core/src/api/handlers/menus.ts
@@ -11,28 +11,32 @@
  * specific row id), so a single menu item target survives content translations.
  */
 
-import type { Kysely, Selectable } from "kysely";
-import { ulid } from "ulidx";
-
-import { withTransaction } from "../../database/transaction.js";
-import type { Database, MenuItemTable, MenuTable } from "../../database/types.js";
+import type { Kysely } from "kysely";
+
+import {
+	MenuGoneError,
+	MenuRepository,
+	type CreateMenuItemInput as CreateMenuItemRepoInput,
+	type Menu,
+	type MenuItem,
+	type MenuListItem,
+	type MenuWithItems,
+	type SetMenuItem,
+	type UpdateMenuItemInput as UpdateMenuItemRepoInput,
+} from "../../database/repositories/menu.js";
+import type { Database } from "../../database/types.js";
 import { getI18nConfig } from "../../i18n/config.js";
 import type { ApiResult } from "../types.js";
 
-// ---------------------------------------------------------------------------
-// Response types
-// ---------------------------------------------------------------------------
-
-export type MenuRow = Selectable<MenuTable>;
-export type MenuItemRow = Selectable<MenuItemTable>;
-
-export interface MenuListItem extends MenuRow {
-	itemCount: number;
-}
-
-export interface MenuWithItems extends MenuRow {
-	items: MenuItemRow[];
-}
+// Re-export entity types so route files and tests can import them from the
+// handler module without having to know about the repository layout.
+export type {
+	Menu,
+	MenuItem,
+	MenuListItem,
+	MenuTranslation,
+	MenuWithItems,
+} from "../../database/repositories/menu.js";
 
 export interface MenuTranslationsResponse {
 	translationGroup: string | null;
@@ -45,6 +49,10 @@ export interface MenuTranslationsResponse {
 	}>;
 }
 
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
 /**
  * Error returned when a menu lookup by `name` matches multiple locale
  * variants and the caller did not pass `locale` to disambiguate. Maps to
@@ -67,62 +75,57 @@ function ambiguousMenuLocaleError(
 	};
 }
 
+type ResolveMenuResult =
+	| { success: true; menu: Menu }
+	| { success: false; error: { code: "NOT_FOUND" | "AMBIGUOUS_LOCALE"; message: string } };
+
+/**
+ * Resolve a menu by name + optional locale to a single Menu, surfacing the
+ * canonical NOT_FOUND / AMBIGUOUS_LOCALE errors. Every item handler relies on
+ * this to translate (name, locale) into an unambiguous menu row.
+ */
+async function resolveMenu(
+	repo: MenuRepository,
+	name: string,
+	options: { locale?: string },
+): Promise<ResolveMenuResult> {
+	const matches = await repo.findByName(name, options);
+	if (matches.length === 0) {
+		return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Menu '${name}' not found${options.locale ? ` in locale '${options.locale}'` : ""}`,
+			},
+		};
+	}
+	if (matches.length > 1) {
+		return {
+			success: false,
+			error: ambiguousMenuLocaleError(
+				name,
+				matches.map((m) => m.locale),
+			).error,
+		};
+	}
+	return { success: true, menu: matches[0] };
+}
+
 // ---------------------------------------------------------------------------
 // Menu handlers
 // ---------------------------------------------------------------------------
 
 /**
- * List menus with item counts. Filter by `locale` when provided; otherwise
- * return every menu row (each locale counts as its own menu for admin listing
- * purposes).
+ * List menus with item counts. Filter by `locale` when provided.
  */
 export async function handleMenuList(
 	db: Kysely<Database>,
 	options: { locale?: string } = {},
 ): Promise<ApiResult<MenuListItem[]>> {
 	try {
-		// Single query: LEFT JOIN + GROUP BY for the per-menu item count.
-		// Avoids the N+1 of one count query per menu.
-		let query = db
-			.selectFrom("_emdash_menus as m")
-			.leftJoin("_emdash_menu_items as i", "i.menu_id", "m.id")
-			.select(({ fn }) => [
-				"m.id",
-				"m.name",
-				"m.label",
-				"m.created_at",
-				"m.updated_at",
-				"m.locale",
-				"m.translation_group",
-				fn.count<number>("i.id").as("itemCount"),
-			])
-			.groupBy([
-				"m.id",
-				"m.name",
-				"m.label",
-				"m.created_at",
-				"m.updated_at",
-				"m.locale",
-				"m.translation_group",
-			])
-			.orderBy("m.name", "asc");
-		if (options.locale !== undefined) query = query.where("m.locale", "=", options.locale);
-		const rows = await query.execute();
-
-		// SQLite returns count as `number`, but some dialects (Postgres)
-		// return `string` from a count() aggregate. Normalize to number.
-		const menusWithCounts: MenuListItem[] = rows.map((row) => ({
-			id: row.id,
-			name: row.name,
-			label: row.label,
-			created_at: row.created_at,
-			updated_at: row.updated_at,
-			locale: row.locale,
-			translation_group: row.translation_group,
-			itemCount: typeof row.itemCount === "string" ? Number(row.itemCount) : row.itemCount,
-		}));
-
-		return { success: true, data: menusWithCounts };
+		const repo = new MenuRepository(db);
+		const items = await repo.findMany(options);
+		return { success: true, data: items };
 	} catch {
 		return {
 			success: false,
@@ -133,12 +136,13 @@ export async function handleMenuList(
 
 /**
  * Create a new menu. When `translationOf` is supplied the new menu joins the
- * source menu's translation_group (and gets the source's items cloned).
+ * source menu's translation_group (and gets the source's items cloned by the
+ * repository).
  */
 export async function handleMenuCreate(
 	db: Kysely<Database>,
 	input: { name: string; label: string; locale?: string; translationOf?: string },
-): Promise<ApiResult<MenuRow>> {
+): Promise<ApiResult<Menu>> {
 	try {
 		// Translating from a source menu only makes sense when the caller
 		// names the target locale: otherwise we'd silently clone into the
@@ -155,35 +159,24 @@ export async function handleMenuCreate(
 			};
 		}
 
-		// Resolve translation group + source (if we're creating a translation).
-		let translationGroup: string | null = null;
-		let sourceMenu: MenuRow | null = null;
+		const repo = new MenuRepository(db);
+
+		// Existence check up front so the repo's "Source not found" throw
+		// becomes a clean NOT_FOUND on the API.
 		if (input.translationOf) {
-			const src = await db
-				.selectFrom("_emdash_menus")
-				.selectAll()
-				.where("id", "=", input.translationOf)
-				.executeTakeFirst();
-			if (!src) {
+			const source = await repo.findById(input.translationOf);
+			if (!source) {
 				return {
 					success: false,
 					error: { code: "NOT_FOUND", message: "Source menu for translation not found" },
 				};
 			}
-			sourceMenu = src;
-			translationGroup = src.translation_group ?? src.id;
 		}
 
 		// Duplicate guard: same (name, locale). Falls back to the configured
 		// defaultLocale to match the column DEFAULT set by migration 036.
 		const effectiveLocale = input.locale ?? getI18nConfig()?.defaultLocale ?? "en";
-		const existing = await db
-			.selectFrom("_emdash_menus")
-			.select("id")
-			.where("name", "=", input.name)
-			.where("locale", "=", effectiveLocale)
-			.executeTakeFirst();
-		if (existing) {
+		if (await repo.existsByNameAndLocale(input.name, effectiveLocale)) {
 			return {
 				success: false,
 				error: {
@@ -195,69 +188,7 @@ export async function handleMenuCreate(
 			};
 		}
 
-		const id = ulid();
-
-		await withTransaction(db, async (trx) => {
-			await trx
-				.insertInto("_emdash_menus")
-				.values({
-					id,
-					name: input.name,
-					label: input.label,
-					...(input.locale !== undefined ? { locale: input.locale } : {}),
-					translation_group: translationGroup ?? id,
-				})
-				.execute();
-
-			// Clone items from the source menu (same reference_ids — they are
-			// translation_groups, which are locale-agnostic). Each clone
-			// inherits the source item's translation_group so a nav entry
-			// identifies as the same logical item across menu translations.
-			if (sourceMenu) {
-				const sourceItems = await trx
-					.selectFrom("_emdash_menu_items")
-					.selectAll()
-					.where("menu_id", "=", sourceMenu.id)
-					.orderBy("sort_order", "asc")
-					.execute();
-				if (sourceItems.length > 0) {
-					// Build old-id → new-id map so parent pointers land on the clones.
-					const idMap = new Map<string, string>();
-					for (const item of sourceItems) idMap.set(item.id, ulid());
-
-					await trx
-						.insertInto("_emdash_menu_items")
-						.values(
-							sourceItems.map((item) => {
-								const newId = idMap.get(item.id)!;
-								return {
-									id: newId,
-									menu_id: id,
-									parent_id: item.parent_id ? (idMap.get(item.parent_id) ?? null) : null,
-									sort_order: item.sort_order,
-									type: item.type,
-									reference_collection: item.reference_collection,
-									reference_id: item.reference_id,
-									custom_url: item.custom_url,
-									label: item.label,
-									title_attr: item.title_attr,
-									target: item.target,
-									css_classes: item.css_classes,
-									...(input.locale !== undefined ? { locale: input.locale } : {}),
-									translation_group: item.translation_group ?? item.id,
-								};
-							}),
-						)
-						.execute();
-				}
-			}
-		});
-
-		const menu = await db
-			.selectFrom("_emdash_menus")
-			.selectAll()
-			.where("id", "=", id)
-			.executeTakeFirstOrThrow();
+		const menu = await repo.create(input);
 		return { success: true, data: menu };
 	} catch {
 		return {
@@ -270,6 +201,9 @@ export async function handleMenuCreate(
 /**
  * Get a single menu by name. Honours an optional `locale` filter; when two
  * menus share a name across locales, the locale distinguishes them.
+ *
+ * Historical behaviour: when `locale` is omitted, returns the lowest-locale
+ * match (deterministic). Mirrors the pre-repo handler.
  */
 export async function handleMenuGet(
 	db: Kysely<Database>,
@@ -277,24 +211,16 @@ export async function handleMenuGet(
 	options: { locale?: string } = {},
 ): Promise<ApiResult<MenuWithItems>> {
 	try {
-		let query = db.selectFrom("_emdash_menus").selectAll().where("name", "=", name);
-		if (options.locale !== undefined) query = query.where("locale", "=", options.locale);
-		const menu = await query.orderBy("locale", "asc").executeTakeFirst();
-
-		if (!menu) {
+		const repo = new MenuRepository(db);
+		const matches = await repo.findByName(name, options);
+		if (matches.length === 0) {
 			return {
 				success: false,
 				error: { code: "NOT_FOUND", message: `Menu '${name}' not found` },
 			};
 		}
-
-		const items = await db
-			.selectFrom("_emdash_menu_items")
-			.selectAll()
-			.where("menu_id", "=", menu.id)
-			.orderBy("sort_order", "asc")
-			.execute();
-
+		const menu = matches[0];
+		const items = await repo.findItems(menu.id);
 		return { success: true, data: { ...menu, items } };
 	} catch {
 		return {
@@ -313,24 +239,15 @@ export async function handleMenuGetById(
 	id: string,
 ): Promise<ApiResult<MenuWithItems>> {
 	try {
-		const menu = await db
-			.selectFrom("_emdash_menus")
-			.selectAll()
-			.where("id", "=", id)
-			.executeTakeFirst();
+		const repo = new MenuRepository(db);
+		const menu = await repo.findWithItems(id);
 		if (!menu) {
 			return {
 				success: false,
 				error: { code: "NOT_FOUND", message: `Menu '${id}' not found` },
 			};
 		}
-		const items = await db
-			.selectFrom("_emdash_menu_items")
-			.selectAll()
-			.where("menu_id", "=", menu.id)
-			.orderBy("sort_order", "asc")
-			.execute();
-		return { success: true, data: { ...menu, items } };
+		return { success: true, data: menu };
 	} catch {
 		return {
 			success: false,
@@ -346,46 +263,18 @@ export async function handleMenuUpdate(
 	db: Kysely<Database>,
 	name: string,
 	input: { label?: string; locale?: string },
-): Promise<ApiResult<MenuRow>> {
+): Promise<ApiResult<Menu>> {
 	try {
-		// Fetch every row matching the name (filtered by locale if supplied)
-		// so we can fail loud when an omitted-locale lookup is ambiguous.
-		// (name, locale) is unique, so length > 1 only happens when the
-		// caller didn't pass `locale` and the menu exists in >1 translation.
-		let query = db.selectFrom("_emdash_menus").select(["id", "locale"]).where("name", "=", name);
-		if (input.locale !== undefined) query = query.where("locale", "=", input.locale);
-		const matches = await query.execute();
-
-		if (matches.length === 0) {
+		const repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, name, { locale: input.locale });
+		if (!resolved.success) return resolved;
+		const updated = await repo.update(resolved.menu.id, { label: input.label });
+		if (!updated) {
 			return {
 				success: false,
-				error: {
-					code: "NOT_FOUND",
-					message: `Menu '${name}' not found${input.locale ? ` in locale '${input.locale}'` : ""}`,
-				},
+				error: { code: "NOT_FOUND", message: `Menu '${name}' not found` },
 			};
 		}
-		if (matches.length > 1) {
-			return ambiguousMenuLocaleError(
-				name,
-				matches.map((m) => m.locale),
-			);
-		}
-		const menu = matches[0]!;
-
-		if (input.label) {
-			await db
-				.updateTable("_emdash_menus")
-				.set({ label: input.label })
-				.where("id", "=", menu.id)
-				.execute();
-		}
-
-		const updated = await db
-			.selectFrom("_emdash_menus")
-			.selectAll()
-			.where("id", "=", menu.id)
-			.executeTakeFirstOrThrow();
 		return { success: true, data: updated };
 	} catch {
 		return {
@@ -396,7 +285,7 @@ export async function handleMenuUpdate(
 }
 
 /**
- * Delete a menu (and items, via cascade).
+ * Delete a menu (and its items, via the repository's explicit cleanup).
  */
 export async function handleMenuDelete(
 	db: Kysely<Database>,
@@ -404,35 +293,10 @@ export async function handleMenuDelete(
 	options: { locale?: string } = {},
 ): Promise<ApiResult<{ deleted: true }>> {
 	try {
-		// See ambiguousMenuLocaleError for why we fetch all matches.
-		let query = db.selectFrom("_emdash_menus").select(["id", "locale"]).where("name", "=", name);
-		if (options.locale !== undefined) query = query.where("locale", "=", options.locale);
-		const matches = await query.execute();
-
-		if (matches.length === 0) {
-			return {
-				success: false,
-				error: {
-					code: "NOT_FOUND",
-					message: `Menu '${name}' not found${
-						options.locale ? ` in locale '${options.locale}'` : ""
-					}`,
-				},
-			};
-		}
-		if (matches.length > 1) {
-			return ambiguousMenuLocaleError(
-				name,
-				matches.map((m) => m.locale),
-			);
-		}
-		const menu = matches[0]!;
-
-		// D1 has FOREIGN KEYS off by default, so the migration's `ON DELETE
-		// CASCADE` won't fire there. Delete items explicitly first — this is
-		// idempotent on SQLite/Postgres where the cascade also fires.
-		await db.deleteFrom("_emdash_menu_items").where("menu_id", "=", menu.id).execute();
-		await db.deleteFrom("_emdash_menus").where("id", "=", menu.id).execute();
+		const repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, name, options);
+		if (!resolved.success) return resolved;
+		await repo.delete(resolved.menu.id);
 		return { success: true, data: { deleted: true } };
 	} catch {
 		return {
@@ -450,37 +314,15 @@ export async function handleMenuTranslations(
 	idOrGroup: string,
 ): Promise<ApiResult<MenuTranslationsResponse>> {
 	try {
-		const anchor = await db
-			.selectFrom("_emdash_menus")
-			.selectAll()
-			.where((eb) => eb.or([eb("id", "=", idOrGroup), eb("translation_group", "=", idOrGroup)]))
-			.executeTakeFirst();
-		if (!anchor) {
+		const repo = new MenuRepository(db);
+		const result = await repo.listTranslations(idOrGroup);
+		if (!result) {
 			return {
 				success: false,
 				error: { code: "NOT_FOUND", message: "Menu not found" },
 			};
 		}
-		const group = anchor.translation_group ?? anchor.id;
-		const rows = await db
-			.selectFrom("_emdash_menus")
-			.selectAll()
-			.where("translation_group", "=", group)
-			.orderBy("locale", "asc")
-			.execute();
-		return {
-			success: true,
-			data: {
-				translationGroup: group,
-				translations: rows.map((row) => ({
-					id: row.id,
-					name: row.name,
-					locale: row.locale,
-					label: row.label,
-					updatedAt: row.updated_at,
-				})),
-			},
-		};
+		return { success: true, data: result };
 	} catch {
 		return {
 			success: false,
@@ -493,91 +335,25 @@ export async function handleMenuTranslations(
 // Menu item handlers
 // ---------------------------------------------------------------------------
 
-export interface CreateMenuItemInput {
-	type: string;
-	label: string;
-	referenceCollection?: string;
-	referenceId?: string;
-	customUrl?: string;
-	target?: string;
-	titleAttr?: string;
-	cssClasses?: string;
-	parentId?: string;
-	sortOrder?: number;
-}
+export type CreateMenuItemInput = CreateMenuItemRepoInput;
+export type UpdateMenuItemInput = UpdateMenuItemRepoInput;
+export type MenuSetItemsInput = SetMenuItem;
 
 /**
- * Add an item to a menu. The item inherits the menu's locale (so listing
- * items by locale stays trivial).
+ * Add an item to a menu. The item inherits the menu's locale.
  */
 export async function handleMenuItemCreate(
 	db: Kysely<Database>,
 	menuName: string,
 	input: CreateMenuItemInput,
 	options: { locale?: string } = {},
-): Promise<ApiResult<MenuItemRow>> {
+): Promise<ApiResult<MenuItem>> {
 	try {
-		// Same fail-loud rule as handleMenuUpdate / Delete / SetItems —
-		// see ambiguousMenuLocaleError for the rationale.
-		let menuQuery = db
-			.selectFrom("_emdash_menus")
-			.select(["id", "locale"])
-			.where("name", "=", menuName);
-		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
-		const matches = await menuQuery.execute();
+		const repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, menuName, options);
+		if (!resolved.success) return resolved;
 
-		if (matches.length === 0) {
-			return {
-				success: false,
-				error: { code: "NOT_FOUND", message: "Menu not found" },
-			};
-		}
-		if (matches.length > 1) {
-			return ambiguousMenuLocaleError(
-				menuName,
-				matches.map((m) => m.locale),
-			);
-		}
-		const menu = matches[0]!;
-
-		let sortOrder = input.sortOrder ?? 0;
-		if (input.sortOrder === undefined) {
-			const maxOrder = await db
-				.selectFrom("_emdash_menu_items")
-				.select(({ fn }) => fn.max("sort_order").as("max"))
-				.where("menu_id", "=", menu.id)
-				.where("parent_id", "is", input.parentId ?? null)
-				.executeTakeFirst();
-			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Kysely fn.max returns unknown; always a number for sort_order column
-			sortOrder = ((maxOrder?.max as number) ?? -1) + 1;
-		}
-
-		const id = ulid();
-		await db
-			.insertInto("_emdash_menu_items")
-			.values({
-				id,
-				menu_id: menu.id,
-				parent_id: input.parentId ?? null,
-				sort_order: sortOrder,
-				type: input.type,
-				reference_collection: input.referenceCollection ?? null,
-				reference_id: input.referenceId ?? null,
-				custom_url: input.customUrl ?? null,
-				label: input.label,
-				title_attr: input.titleAttr ?? null,
-				target: input.target ?? null,
-				css_classes: input.cssClasses ?? null,
-				locale: menu.locale,
-				translation_group: id,
-			})
-			.execute();
-
-		const item = await db
-			.selectFrom("_emdash_menu_items")
-			.selectAll()
-			.where("id", "=", id)
-			.executeTakeFirstOrThrow();
+		const item = await repo.createItem(resolved.menu.id, resolved.menu.locale, input);
 		return { success: true, data: item };
 	} catch {
 		return {
@@ -587,16 +363,6 @@ export async function handleMenuItemCreate(
 	}
 }
 
-export interface UpdateMenuItemInput {
-	label?: string;
-	customUrl?: string;
-	target?: string;
-	titleAttr?: string;
-	cssClasses?: string;
-	parentId?: string | null;
-	sortOrder?: number;
-}
-
 /**
  * Update a menu item.
  */
@@ -606,62 +372,19 @@ export async function handleMenuItemUpdate(
 	itemId: string,
 	input: UpdateMenuItemInput,
 	options: { locale?: string } = {},
-): Promise<ApiResult<MenuItemRow>> {
+): Promise<ApiResult<MenuItem>> {
 	try {
-		// See ambiguousMenuLocaleError for the rationale.
-		let menuQuery = db
-			.selectFrom("_emdash_menus")
-			.select(["id", "locale"])
-			.where("name", "=", menuName);
-		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
-		const matches = await menuQuery.execute();
-
-		if (matches.length === 0) {
-			return {
-				success: false,
-				error: { code: "NOT_FOUND", message: "Menu not found" },
-			};
-		}
-		if (matches.length > 1) {
-			return ambiguousMenuLocaleError(
-				menuName,
-				matches.map((m) => m.locale),
-			);
-		}
-		const menu = matches[0]!;
+		const repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, menuName, options);
+		if (!resolved.success) return resolved;
 
-		const item = await db
-			.selectFrom("_emdash_menu_items")
-			.select("id")
-			.where("id", "=", itemId)
-			.where("menu_id", "=", menu.id)
-			.executeTakeFirst();
-
-		if (!item) {
+		const updated = await repo.updateItem(resolved.menu.id, itemId, input);
+		if (!updated) {
 			return {
 				success: false,
 				error: { code: "NOT_FOUND", message: "Menu item not found" },
 			};
 		}
-
-		const updates: Record<string, unknown> = {};
-		if (input.label !== undefined) updates.label = input.label;
-		if (input.customUrl !== undefined) updates.custom_url = input.customUrl;
-		if (input.target !== undefined) updates.target = input.target;
-		if (input.titleAttr !== undefined) updates.title_attr = input.titleAttr;
-		if (input.cssClasses !== undefined) updates.css_classes = input.cssClasses;
-		if (input.parentId !== undefined) updates.parent_id = input.parentId;
-		if (input.sortOrder !== undefined) updates.sort_order = input.sortOrder;
-
-		if (Object.keys(updates).length > 0) {
-			await db.updateTable("_emdash_menu_items").set(updates).where("id", "=", itemId).execute();
-		}
-
-		const updated = await db
-			.selectFrom("_emdash_menu_items")
-			.selectAll()
-			.where("id", "=", itemId)
-			.executeTakeFirstOrThrow();
 		return { success: true, data: updated };
 	} catch {
 		return {
@@ -681,41 +404,17 @@ export async function handleMenuItemDelete(
 	options: { locale?: string } = {},
 ): Promise<ApiResult<{ deleted: true }>> {
 	try {
-		// See ambiguousMenuLocaleError for the rationale.
-		let menuQuery = db
-			.selectFrom("_emdash_menus")
-			.select(["id", "locale"])
-			.where("name", "=", menuName);
-		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
-		const matches = await menuQuery.execute();
-
-		if (matches.length === 0) {
-			return {
-				success: false,
-				error: { code: "NOT_FOUND", message: "Menu not found" },
-			};
-		}
-		if (matches.length > 1) {
-			return ambiguousMenuLocaleError(
-				menuName,
-				matches.map((m) => m.locale),
-			);
-		}
-		const menu = matches[0]!;
-
-		const result = await db
-			.deleteFrom("_emdash_menu_items")
-			.where("id", "=", itemId)
-			.where("menu_id", "=", menu.id)
-			.execute();
+		const repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, menuName, options);
+		if (!resolved.success) return resolved;
 
-		if (result[0]?.numDeletedRows === 0n) {
+		const deleted = await repo.deleteItem(resolved.menu.id, itemId);
+		if (!deleted) {
 			return {
 				success: false,
 				error: { code: "NOT_FOUND", message: "Menu item not found" },
 			};
 		}
-
 		return { success: true, data: { deleted: true } };
 	} catch {
 		return {
@@ -732,26 +431,9 @@ export interface ReorderItem {
 }
 
 // ---------------------------------------------------------------------------
-// Atomic-replace menu items (used by the MCP `menu_set_items` tool)
+// Atomic-replace menu items (used by the MCP `menu_set_items` tool and admin)
 // ---------------------------------------------------------------------------
 
-export interface MenuSetItemsInput {
-	label: string;
-	type: "custom" | "page" | "post" | "taxonomy" | "collection";
-	customUrl?: string;
-	referenceCollection?: string;
-	referenceId?: string;
-	titleAttr?: string;
-	target?: string;
-	cssClasses?: string;
-	/**
-	 * Index of the parent item in this same array. Must be strictly less
-	 * than the current item's index so the insert order resolves parents
-	 * before children. `undefined` makes the item top-level.
-	 */
-	parentIndex?: number;
-}
-
 /**
  * Replace the entire set of items for a menu in one atomic transaction.
  *
@@ -765,11 +447,10 @@ export async function handleMenuSetItems(
 	items: MenuSetItemsInput[],
 	options: { locale?: string } = {},
 ): Promise<ApiResult<{ name: string; itemCount: number }>> {
-	// Validate parentIndex references — must be strictly earlier so
-	// the array can be inserted in order with parents resolved first.
-	// Negative indices are out of range; only Zod's `.nonnegative()` at
-	// the MCP boundary catches them today, so guard explicitly here for
-	// any caller that bypasses Zod (REST routes, direct handler use).
+	// Validate parentIndex references — must be strictly earlier so the array
+	// can be inserted in order with parents resolved first. Negative indices
+	// are caught by Zod's `.nonnegative()` at the MCP boundary, but we guard
+	// explicitly so REST routes / direct handler use get the same error.
 	for (let i = 0; i < items.length; i++) {
 		const item = items[i];
 		if (item?.parentIndex !== undefined) {
@@ -786,95 +467,29 @@ export async function handleMenuSetItems(
 	}
 
 	try {
-		// Sentinels thrown from inside the transaction so the rollback
-		// fires before we return the structured error.
-		const notFoundSentinel = Symbol("menu-not-found");
-		// We capture the locale list rather than constructing the error
-		// inside the transaction, so the helper stays the single source
-		// of truth for AMBIGUOUS_LOCALE message shape.
-		let ambiguousLocales: string[] | null = null;
-		const ambiguousSentinel = Symbol("menu-ambiguous-locale");
-
-		try {
-			await withTransaction(db, async (trx) => {
-				// Existence check INSIDE the transaction so a concurrent
-				// menu_delete between lookup and write can't leave orphan
-				// items on D1 (FKs disabled by default). Same fail-loud
-				// rule as handleMenuUpdate / handleMenuDelete.
-				let menuQuery = trx
-					.selectFrom("_emdash_menus")
-					.select(["id", "locale"])
-					.where("name", "=", menuName);
-				if (options.locale !== undefined) {
-					menuQuery = menuQuery.where("locale", "=", options.locale);
-				}
-				const matches = await menuQuery.execute();
-
-				if (matches.length === 0) {
-					throw notFoundSentinel;
-				}
-				if (matches.length > 1) {
-					ambiguousLocales = matches.map((m) => m.locale);
-					throw ambiguousSentinel;
-				}
-				const menu = matches[0]!;
-
-				await trx.deleteFrom("_emdash_menu_items").where("menu_id", "=", menu.id).execute();
-
-				const insertedIds: string[] = [];
-				for (let i = 0; i < items.length; i++) {
-					const item = items[i];
-					if (!item) continue;
-					const id = ulid();
-					const parentId =
-						item.parentIndex !== undefined ? (insertedIds[item.parentIndex] ?? null) : null;
-					await trx
-						.insertInto("_emdash_menu_items")
-						.values({
-							id,
-							menu_id: menu.id,
-							parent_id: parentId,
-							sort_order: i,
-							type: item.type,
-							reference_collection: item.referenceCollection ?? null,
-							reference_id: item.referenceId ?? null,
-							custom_url: item.customUrl ?? null,
-							label: item.label,
-							title_attr: item.titleAttr ?? null,
-							target: item.target ?? null,
-							css_classes: item.cssClasses ?? null,
-							locale: menu.locale,
-						})
-						.execute();
-					insertedIds.push(id);
-				}
-
-				await trx
-					.updateTable("_emdash_menus")
-					.set({ updated_at: new Date().toISOString() })
-					.where("id", "=", menu.id)
-					.execute();
-			});
-		} catch (error) {
-			if (error === notFoundSentinel) {
-				return {
-					success: false,
-					error: {
-						code: "NOT_FOUND",
-						message: `Menu '${menuName}' not found${
-							options.locale ? ` in locale '${options.locale}'` : ""
-						}`,
-					},
-				};
-			}
-			if (error === ambiguousSentinel && ambiguousLocales) {
-				return ambiguousMenuLocaleError(menuName, ambiguousLocales);
-			}
-			throw error;
-		}
+		const repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, menuName, options);
+		if (!resolved.success) return resolved;
 
-		return { success: true, data: { name: menuName, itemCount: items.length } };
+		const { itemCount } = await repo.setItems(resolved.menu.id, resolved.menu.locale, items);
+		return { success: true, data: { name: menuName, itemCount } };
 	} catch (error) {
+		// `MenuGoneError` is thrown from inside the repository transaction
+		// when the menu was deleted concurrently between `resolveMenu` and the
+		// setItems write. Returning NOT_FOUND mirrors the original handler's
+		// in-transaction `notFoundSentinel` branch and keeps the response
+		// shape stable for REST/MCP callers.
+		if (error instanceof MenuGoneError) {
+			return {
+				success: false,
+				error: {
+					code: "NOT_FOUND",
+					message: `Menu '${menuName}' not found${
+						options.locale ? ` in locale '${options.locale}'` : ""
+					}`,
+				},
+			};
+		}
 		console.error("[emdash] handleMenuSetItems failed:", error);
 		return {
 			success: false,
@@ -891,52 +506,14 @@ export async function handleMenuItemReorder(
 	menuName: string,
 	items: ReorderItem[],
 	options: { locale?: string } = {},
-): Promise<ApiResult<MenuItemRow[]>> {
+): Promise<ApiResult<MenuItem[]>> {
 	try {
-		// See ambiguousMenuLocaleError for the rationale.
-		let menuQuery = db
-			.selectFrom("_emdash_menus")
-			.select(["id", "locale"])
-			.where("name", "=", menuName);
-		if (options.locale !== undefined) menuQuery = menuQuery.where("locale", "=", options.locale);
-		const matches = await menuQuery.execute();
+		const repo = new MenuRepository(db);
+		const resolved = await resolveMenu(repo, menuName, options);
+		if (!resolved.success) return resolved;
 
-		if (matches.length === 0) {
-			return {
-				success: false,
-				error: { code: "NOT_FOUND", message: "Menu not found" },
-			};
-		}
-		if (matches.length > 1) {
-			return ambiguousMenuLocaleError(
-				menuName,
-				matches.map((m) => m.locale),
-			);
-		}
-		const menu = matches[0]!;
-
-		const updatedItems = await withTransaction(db, async (trx) => {
-			for (const item of items) {
-				await trx
-					.updateTable("_emdash_menu_items")
-					.set({
-						parent_id: item.parentId,
-						sort_order: item.sortOrder,
-					})
-					.where("id", "=", item.id)
-					.where("menu_id", "=", menu.id)
-					.execute();
-			}
-
-			return trx
-				.selectFrom("_emdash_menu_items")
-				.selectAll()
-				.where("menu_id", "=", menu.id)
-				.orderBy("sort_order", "asc")
-				.execute();
-		});
-
-		return { success: true, data: updatedItems };
+		const updated = await repo.reorderItems(resolved.menu.id, items);
+		return { success: true, data: updated };
 	} catch {
 		return {
 			success: false,
diff --git a/packages/core/src/api/openapi/document.ts b/packages/core/src/api/openapi/document.ts
index 8e27deae2..1f82aaf2d 100644
--- a/packages/core/src/api/openapi/document.ts
+++ b/packages/core/src/api/openapi/document.ts
@@ -1416,13 +1416,17 @@ const menuPaths = {
 				...standardErrors(400, 404, 500),
 			},
 		},
+	},
+	"/_emdash/api/menus/{name}/items/{id}": {
 		put: {
 			operationId: "updateMenuItem",
 			summary: "Update a menu item",
 			tags: ["Menus"],
 			requestParams: {
-				path: z.object({ name: z.string().meta({ description: "Menu name" }) }),
-				query: z.object({ id: z.string().meta({ description: "Menu item ID" }) }),
+				path: z.object({
+					name: z.string().meta({ description: "Menu name" }),
+					id: z.string().meta({ description: "Menu item id" }),
+				}),
 			},
 			requestBody: { content: { [JSON_CONTENT]: { schema: updateMenuItemBody } } },
 			responses: {
@@ -1439,8 +1443,10 @@ const menuPaths = {
 			summary: "Delete a menu item",
 			tags: ["Menus"],
 			requestParams: {
-				path: z.object({ name: z.string().meta({ description: "Menu name" }) }),
-				query: z.object({ id: z.string().meta({ description: "Menu item ID" }) }),
+				path: z.object({
+					name: z.string().meta({ description: "Menu name" }),
+					id: z.string().meta({ description: "Menu item id" }),
+				}),
 			},
 			responses: {
 				"200": {
diff --git a/packages/core/src/api/schemas/menus.ts b/packages/core/src/api/schemas/menus.ts
index 848331077..f7d7b046e 100644
--- a/packages/core/src/api/schemas/menus.ts
+++ b/packages/core/src/api/schemas/menus.ts
@@ -6,7 +6,11 @@ import { isSafeHref } from "../../utils/url.js";
 // Menus: Input schemas
 // ---------------------------------------------------------------------------
 
-const menuItemType = z.string().min(1);
+/**
+ * Allowed menu item types. `custom` uses `customUrl`; the others resolve a URL
+ * from `referenceCollection` + `referenceId` (a translation_group id).
+ */
+export const menuItemTypeEnum = z.enum(["custom", "page", "post", "taxonomy", "collection"]);
 
 const safeHref = z
 	.string()
@@ -25,17 +29,19 @@ export const createMenuBody = z
 		 * the source's translation_group. */
 		translationOf: z.string().min(1).optional(),
 	})
+	.strict()
 	.meta({ id: "CreateMenuBody" });
 
 export const updateMenuBody = z
 	.object({
 		label: z.string().min(1).optional(),
 	})
+	.strict()
 	.meta({ id: "UpdateMenuBody" });
 
 export const createMenuItemBody = z
 	.object({
-		type: menuItemType,
+		type: menuItemTypeEnum,
 		label: z.string().min(1),
 		referenceCollection: z.string().optional(),
 		referenceId: z.string().optional(),
@@ -46,6 +52,7 @@ export const createMenuItemBody = z
 		parentId: z.string().optional(),
 		sortOrder: z.number().int().min(0).optional(),
 	})
+	.strict()
 	.meta({ id: "CreateMenuItemBody" });
 
 export const updateMenuItemBody = z
@@ -58,16 +65,9 @@ export const updateMenuItemBody = z
 		parentId: z.string().nullish(),
 		sortOrder: z.number().int().min(0).optional(),
 	})
+	.strict()
 	.meta({ id: "UpdateMenuItemBody" });
 
-export const menuItemDeleteQuery = z.object({
-	id: z.string().min(1),
-});
-
-export const menuItemUpdateQuery = z.object({
-	id: z.string().min(1),
-});
-
 export const reorderMenuItemsBody = z
 	.object({
 		items: z.array(
@@ -82,6 +82,10 @@ export const reorderMenuItemsBody = z
 
 // ---------------------------------------------------------------------------
 // Menus: Response schemas
+//
+// All responses are camelCase to align with the rest of the EmDash REST API
+// (content, taxonomies, redirects, etc.). The DB columns are snake_case;
+// handlers hydrate rows into the shapes below before returning.
 // ---------------------------------------------------------------------------
 
 export const menuSchema = z
@@ -89,30 +93,30 @@ export const menuSchema = z
 		id: z.string(),
 		name: z.string(),
 		label: z.string(),
-		created_at: z.string(),
-		updated_at: z.string(),
+		createdAt: z.string(),
+		updatedAt: z.string(),
 		locale: z.string(),
-		translation_group: z.string().nullable(),
+		translationGroup: z.string().nullable(),
 	})
 	.meta({ id: "Menu" });
 
 export const menuItemSchema = z
 	.object({
 		id: z.string(),
-		menu_id: z.string(),
-		parent_id: z.string().nullable(),
-		sort_order: z.number().int(),
+		menuId: z.string(),
+		parentId: z.string().nullable(),
+		sortOrder: z.number().int(),
 		type: z.string(),
-		reference_collection: z.string().nullable(),
-		reference_id: z.string().nullable(),
-		custom_url: z.string().nullable(),
+		referenceCollection: z.string().nullable(),
+		referenceId: z.string().nullable(),
+		customUrl: z.string().nullable(),
 		label: z.string(),
-		title_attr: z.string().nullable(),
+		titleAttr: z.string().nullable(),
 		target: z.string().nullable(),
-		css_classes: z.string().nullable(),
-		created_at: z.string(),
+		cssClasses: z.string().nullable(),
+		createdAt: z.string(),
 		locale: z.string(),
-		translation_group: z.string().nullable(),
+		translationGroup: z.string().nullable(),
 	})
 	.meta({ id: "MenuItem" });
 
diff --git a/packages/core/src/astro/integration/routes.ts b/packages/core/src/astro/integration/routes.ts
index a5a2659cf..14010a756 100644
--- a/packages/core/src/astro/integration/routes.ts
+++ b/packages/core/src/astro/integration/routes.ts
@@ -561,6 +561,11 @@ export function injectCoreRoutes(injectRoute: InjectRoute): void {
 		entrypoint: resolveRoute("api/menus/[name]/items.ts"),
 	});
 
+	injectRoute({
+		pattern: "/_emdash/api/menus/[name]/items/[id]",
+		entrypoint: resolveRoute("api/menus/[name]/items/[id].ts"),
+	});
+
 	injectRoute({
 		pattern: "/_emdash/api/menus/[name]/reorder",
 		entrypoint: resolveRoute("api/menus/[name]/reorder.ts"),
diff --git a/packages/core/src/astro/routes/api/menus/[name]/items.ts b/packages/core/src/astro/routes/api/menus/[name]/items.ts
index 1e42c2dd8..5854267a8 100644
--- a/packages/core/src/astro/routes/api/menus/[name]/items.ts
+++ b/packages/core/src/astro/routes/api/menus/[name]/items.ts
@@ -1,28 +1,16 @@
 /**
- * Menu items CRUD endpoints
+ * Menu items create endpoint
  *
- * POST   /_emdash/api/menus/:name/items[?locale=xx]
- * PUT    /_emdash/api/menus/:name/items?id=...[&locale=xx]
- * DELETE /_emdash/api/menus/:name/items?id=...[&locale=xx]
+ * POST /_emdash/api/menus/:name/items[?locale=xx] - Create a new menu item
  */
 
 import type { APIRoute } from "astro";
 
 import { requirePerm } from "#api/authorize.js";
 import { handleError, unwrapResult } from "#api/error.js";
-import {
-	handleMenuItemCreate,
-	handleMenuItemDelete,
-	handleMenuItemUpdate,
-} from "#api/handlers/menus.js";
+import { handleMenuItemCreate } from "#api/handlers/menus.js";
 import { isParseError, parseBody, parseQuery } from "#api/parse.js";
-import {
-	createMenuItemBody,
-	localeFilterQuery,
-	menuItemDeleteQuery,
-	menuItemUpdateQuery,
-	updateMenuItemBody,
-} from "#api/schemas.js";
+import { createMenuItemBody, localeFilterQuery } from "#api/schemas.js";
 
 export const prerender = false;
 
@@ -46,52 +34,3 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 		return handleError(error, "Failed to create menu item", "MENU_ITEM_CREATE_ERROR");
 	}
 };
-
-export const PUT: APIRoute = async ({ params, request, locals }) => {
-	const { emdash, user } = locals;
-	const name = params.name!;
-
-	const denied = requirePerm(user, "menus:manage");
-	if (denied) return denied;
-
-	const url = new URL(request.url);
-	const query = parseQuery(url, menuItemUpdateQuery);
-	if (isParseError(query)) return query;
-	const localeQ = parseQuery(url, localeFilterQuery);
-	if (isParseError(localeQ)) return localeQ;
-	const itemId = query.id;
-
-	try {
-		const body = await parseBody(request, updateMenuItemBody);
-		if (isParseError(body)) return body;
-
-		const result = await handleMenuItemUpdate(emdash.db, name, itemId, body, {
-			locale: localeQ.locale,
-		});
-		return unwrapResult(result);
-	} catch (error) {
-		return handleError(error, "Failed to update menu item", "MENU_ITEM_UPDATE_ERROR");
-	}
-};
-
-export const DELETE: APIRoute = async ({ params, request, locals }) => {
-	const { emdash, user } = locals;
-	const name = params.name!;
-
-	const denied = requirePerm(user, "menus:manage");
-	if (denied) return denied;
-
-	const url = new URL(request.url);
-	const query = parseQuery(url, menuItemDeleteQuery);
-	if (isParseError(query)) return query;
-	const localeQ = parseQuery(url, localeFilterQuery);
-	if (isParseError(localeQ)) return localeQ;
-	const itemId = query.id;
-
-	try {
-		const result = await handleMenuItemDelete(emdash.db, name, itemId, { locale: localeQ.locale });
-		return unwrapResult(result);
-	} catch (error) {
-		return handleError(error, "Failed to delete menu item", "MENU_ITEM_DELETE_ERROR");
-	}
-};
diff --git a/packages/core/src/astro/routes/api/menus/[name]/items/[id].ts b/packages/core/src/astro/routes/api/menus/[name]/items/[id].ts
new file mode 100644
index 000000000..4904a10ee
--- /dev/null
+++ b/packages/core/src/astro/routes/api/menus/[name]/items/[id].ts
@@ -0,0 +1,69 @@
+/**
+ * Single menu item endpoint
+ *
+ * PUT    /_emdash/api/menus/:name/items/:id[?locale=xx]
+ * DELETE /_emdash/api/menus/:name/items/:id[?locale=xx]
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, handleError, unwrapResult } from "#api/error.js";
+import { handleMenuItemDelete, handleMenuItemUpdate } from "#api/handlers/menus.js";
+import { isParseError, parseBody, parseQuery } from "#api/parse.js";
+import { localeFilterQuery, updateMenuItemBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const PUT: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const name = params.name!;
+	const itemId = params.id;
+
+	const denied = requirePerm(user, "menus:manage");
+	if (denied) return denied;
+
+	if (!itemId) {
+		return apiError("VALIDATION_ERROR", "id is required", 400);
+	}
+
+	const localeQ = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
+
+	try {
+		const body = await parseBody(request, updateMenuItemBody);
+		if (isParseError(body)) return body;
+
+		const result = await handleMenuItemUpdate(emdash.db, name, itemId, body, {
+			locale: localeQ.locale,
+		});
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to update menu item", "MENU_ITEM_UPDATE_ERROR");
+	}
+};
+
+export const DELETE: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const name = params.name!;
+	const itemId = params.id;
+
+	const denied = requirePerm(user, "menus:manage");
+	if (denied) return denied;
+
+	if (!itemId) {
+		return apiError("VALIDATION_ERROR", "id is required", 400);
+	}
+
+	const localeQ = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
+
+	try {
+		const result = await handleMenuItemDelete(emdash.db, name, itemId, {
+			locale: localeQ.locale,
+		});
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to delete menu item", "MENU_ITEM_DELETE_ERROR");
+	}
+};
diff --git a/packages/core/src/database/repositories/index.ts b/packages/core/src/database/repositories/index.ts
index a2321a935..f2474aacd 100644
--- a/packages/core/src/database/repositories/index.ts
+++ b/packages/core/src/database/repositories/index.ts
@@ -23,6 +23,20 @@ export {
 	deleteAllPluginStorage,
 	deletePluginCollection,
 } from "./plugin-storage.js";
+export { MenuGoneError, MenuRepository } from "./menu.js";
+export type {
+	Menu,
+	MenuItem,
+	MenuListItem,
+	MenuWithItems,
+	MenuTranslation,
+	CreateMenuInput,
+	UpdateMenuInput,
+	CreateMenuItemInput,
+	UpdateMenuItemInput,
+	SetMenuItem,
+	ReorderItem,
+} from "./menu.js";
 export { RedirectRepository } from "./redirect.js";
 export { BylineRepository } from "./byline.js";
 export type { CreateBylineInput, UpdateBylineInput, ContentBylineInput } from "./byline.js";
diff --git a/packages/core/src/database/repositories/menu.ts b/packages/core/src/database/repositories/menu.ts
new file mode 100644
index 000000000..867f72d32
--- /dev/null
+++ b/packages/core/src/database/repositories/menu.ts
@@ -0,0 +1,641 @@
+/**
+ * Menu repository
+ *
+ * Owns every SQL touch for `_emdash_menus` and `_emdash_menu_items`, plus the
+ * row→entity mapping. Matches the architecture used by every other resource
+ * (content, taxonomies, redirects, comments, media): handlers stay thin and
+ * orchestrate; the repository is the single place where snake_case DB columns
+ * become camelCase entities (and vice versa).
+ *
+ * i18n: menus are per-locale. `(name, locale)` is unique. Translations of the
+ * same menu share a `translation_group` ULID. Menu item `reference_id` stores
+ * the referenced content's translation_group (not a specific row id) so a
+ * single menu item survives content translations.
+ */
+
+import type { Kysely, Selectable } from "kysely";
+import { ulid } from "ulidx";
+
+import { withTransaction } from "../transaction.js";
+import type { Database, MenuItemTable, MenuTable } from "../types.js";
+
+/**
+ * Thrown from inside a repository transaction when the menu the caller
+ * resolved earlier has since been deleted. Handlers translate this to a
+ * `NOT_FOUND` API response. Necessary because D1 disables FK enforcement
+ * (so `ON DELETE CASCADE` won't fire), and an unchecked `setItems` would
+ * happily insert items whose `menu_id` no longer exists, leaving orphans.
+ */
+export class MenuGoneError extends Error {
+	constructor(public readonly menuId: string) {
+		super(`Menu ${menuId} was deleted while being modified`);
+		this.name = "MenuGoneError";
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Entity shapes (camelCase — what the API returns)
+// ---------------------------------------------------------------------------
+
+export interface Menu {
+	id: string;
+	name: string;
+	label: string;
+	createdAt: string;
+	updatedAt: string;
+	locale: string;
+	translationGroup: string | null;
+}
+
+export interface MenuItem {
+	id: string;
+	menuId: string;
+	parentId: string | null;
+	sortOrder: number;
+	type: string;
+	referenceCollection: string | null;
+	referenceId: string | null;
+	customUrl: string | null;
+	label: string;
+	titleAttr: string | null;
+	target: string | null;
+	cssClasses: string | null;
+	createdAt: string;
+	locale: string;
+	translationGroup: string | null;
+}
+
+export interface MenuListItem extends Menu {
+	itemCount: number;
+}
+
+export interface MenuWithItems extends Menu {
+	items: MenuItem[];
+}
+
+export interface MenuTranslation {
+	id: string;
+	name: string;
+	label: string;
+	locale: string;
+	updatedAt: string;
+}
+
+// ---------------------------------------------------------------------------
+// Input shapes
+// ---------------------------------------------------------------------------
+
+export interface CreateMenuInput {
+	name: string;
+	label: string;
+	locale?: string;
+	/**
+	 * When set, the new menu joins the source menu's translation_group and
+	 * inherits its items (cloned, with new ULIDs but the same translation_group
+	 * per item so nav entries stay logically identified across translations).
+	 */
+	translationOf?: string;
+}
+
+export interface UpdateMenuInput {
+	label?: string;
+}
+
+export interface CreateMenuItemInput {
+	type: string;
+	label: string;
+	referenceCollection?: string;
+	referenceId?: string;
+	customUrl?: string;
+	target?: string;
+	titleAttr?: string;
+	cssClasses?: string;
+	parentId?: string;
+	sortOrder?: number;
+}
+
+export interface UpdateMenuItemInput {
+	label?: string;
+	customUrl?: string;
+	target?: string;
+	titleAttr?: string;
+	cssClasses?: string;
+	parentId?: string | null;
+	sortOrder?: number;
+}
+
+/**
+ * Item shape used by `setItems()`. Items are placed by array order. Children
+ * point at parents via `parentIndex` (must reference an earlier index, so the
+ * insert can resolve parents before children). The validation of that ordering
+ * lives at the API boundary (`handleMenuSetItems`) so REST/MCP callers receive
+ * the same error shape.
+ */
+export interface SetMenuItem {
+	label: string;
+	type: "custom" | "page" | "post" | "taxonomy" | "collection";
+	customUrl?: string;
+	referenceCollection?: string;
+	referenceId?: string;
+	titleAttr?: string;
+	target?: string;
+	cssClasses?: string;
+	parentIndex?: number;
+}
+
+export interface ReorderItem {
+	id: string;
+	parentId: string | null;
+	sortOrder: number;
+}
+
+// ---------------------------------------------------------------------------
+// Row → entity mappers
+// ---------------------------------------------------------------------------
+
+function rowToMenu(row: Selectable<MenuTable>): Menu {
+	return {
+		id: row.id,
+		name: row.name,
+		label: row.label,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		locale: row.locale,
+		translationGroup: row.translation_group,
+	};
+}
+
+function rowToMenuItem(row: Selectable<MenuItemTable>): MenuItem {
+	return {
+		id: row.id,
+		menuId: row.menu_id,
+		parentId: row.parent_id,
+		sortOrder: row.sort_order,
+		type: row.type,
+		referenceCollection: row.reference_collection,
+		referenceId: row.reference_id,
+		customUrl: row.custom_url,
+		label: row.label,
+		titleAttr: row.title_attr,
+		target: row.target,
+		cssClasses: row.css_classes,
+		createdAt: row.created_at,
+		locale: row.locale,
+		translationGroup: row.translation_group,
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Repository
+// ---------------------------------------------------------------------------
+
+export class MenuRepository {
+	constructor(private db: Kysely<Database>) {}
+
+	// --- Menus -------------------------------------------------------------
+
+	/**
+	 * List menus with their item counts. When `locale` is omitted, returns
+	 * every locale variant as its own row (consistent with the admin listing
+	 * model: each translation is its own menu for editing purposes).
+	 */
+	async findMany(options: { locale?: string } = {}): Promise<MenuListItem[]> {
+		// Single LEFT JOIN + GROUP BY for the per-menu count. Avoids N+1.
+		let query = this.db
+			.selectFrom("_emdash_menus as m")
+			.leftJoin("_emdash_menu_items as i", "i.menu_id", "m.id")
+			.select(({ fn }) => [
+				"m.id",
+				"m.name",
+				"m.label",
+				"m.created_at",
+				"m.updated_at",
+				"m.locale",
+				"m.translation_group",
+				fn.count<number>("i.id").as("itemCount"),
+			])
+			.groupBy([
+				"m.id",
+				"m.name",
+				"m.label",
+				"m.created_at",
+				"m.updated_at",
+				"m.locale",
+				"m.translation_group",
+			])
+			.orderBy("m.name", "asc");
+		if (options.locale !== undefined) query = query.where("m.locale", "=", options.locale);
+		const rows = await query.execute();
+
+		return rows.map((row) => ({
+			// Postgres returns count() as `string`; SQLite as `number`. Normalize.
+			itemCount: typeof row.itemCount === "string" ? Number(row.itemCount) : row.itemCount,
+			...rowToMenu({
+				id: row.id,
+				name: row.name,
+				label: row.label,
+				created_at: row.created_at,
+				updated_at: row.updated_at,
+				locale: row.locale,
+				translation_group: row.translation_group,
+			}),
+		}));
+	}
+
+	/**
+	 * Find every menu row matching `name` (one per locale on multi-locale
+	 * installs). Callers use this both to look up a single menu (when locale
+	 * is supplied) and to detect AMBIGUOUS_LOCALE situations (`length > 1`).
+	 */
+	async findByName(name: string, options: { locale?: string } = {}): Promise<Menu[]> {
+		let query = this.db
+			.selectFrom("_emdash_menus")
+			.selectAll()
+			.where("name", "=", name)
+			.orderBy("locale", "asc");
+		if (options.locale !== undefined) query = query.where("locale", "=", options.locale);
+		const rows = await query.execute();
+		return rows.map(rowToMenu);
+	}
+
+	async findById(id: string): Promise<Menu | null> {
+		const row = await this.db
+			.selectFrom("_emdash_menus")
+			.selectAll()
+			.where("id", "=", id)
+			.executeTakeFirst();
+		return row ? rowToMenu(row) : null;
+	}
+
+	/** Fetch a menu plus its items, ordered by `sort_order`. */
+	async findWithItems(menuId: string): Promise<MenuWithItems | null> {
+		const menu = await this.findById(menuId);
+		if (!menu) return null;
+		const items = await this.findItems(menuId);
+		return { ...menu, items };
+	}
+
+	async findItems(menuId: string): Promise<MenuItem[]> {
+		const rows = await this.db
+			.selectFrom("_emdash_menu_items")
+			.selectAll()
+			.where("menu_id", "=", menuId)
+			.orderBy("sort_order", "asc")
+			.execute();
+		return rows.map(rowToMenuItem);
+	}
+
+	/**
+	 * Returns true when a menu already exists for the given `(name, locale)`.
+	 * Used by the handler to surface a CONFLICT before attempting the insert.
+	 */
+	async existsByNameAndLocale(name: string, locale: string): Promise<boolean> {
+		const row = await this.db
+			.selectFrom("_emdash_menus")
+			.select("id")
+			.where("name", "=", name)
+			.where("locale", "=", locale)
+			.executeTakeFirst();
+		return row !== undefined;
+	}
+
+	/**
+	 * Create a menu. When `translationOf` is supplied the new menu joins the
+	 * source menu's translation_group and clones its items (each clone gets a
+	 * fresh ULID, but inherits the source item's `translation_group` so a
+	 * given nav entry resolves to "the same item" across menu translations).
+	 *
+	 * If the source menu is missing this throws — callers should validate
+	 * existence via `findById` first to return a clean NOT_FOUND.
+	 */
+	async create(input: CreateMenuInput): Promise<Menu> {
+		const id = ulid();
+
+		let translationGroup: string = id;
+		let sourceMenuId: string | null = null;
+		if (input.translationOf) {
+			const source = await this.findById(input.translationOf);
+			if (!source) throw new Error("Source menu for translation not found");
+			translationGroup = source.translationGroup ?? source.id;
+			sourceMenuId = source.id;
+		}
+
+		await withTransaction(this.db, async (trx) => {
+			await trx
+				.insertInto("_emdash_menus")
+				.values({
+					id,
+					name: input.name,
+					label: input.label,
+					...(input.locale !== undefined ? { locale: input.locale } : {}),
+					translation_group: translationGroup,
+				})
+				.execute();
+
+			if (sourceMenuId) {
+				const sourceItems = await trx
+					.selectFrom("_emdash_menu_items")
+					.selectAll()
+					.where("menu_id", "=", sourceMenuId)
+					.orderBy("sort_order", "asc")
+					.execute();
+				if (sourceItems.length > 0) {
+					// old-id → new-id map so parent pointers land on the clones.
+					const idMap = new Map<string, string>();
+					for (const item of sourceItems) idMap.set(item.id, ulid());
+
+					await trx
+						.insertInto("_emdash_menu_items")
+						.values(
+							sourceItems.map((item) => ({
+								id: idMap.get(item.id)!,
+								menu_id: id,
+								parent_id: item.parent_id ? (idMap.get(item.parent_id) ?? null) : null,
+								sort_order: item.sort_order,
+								type: item.type,
+								reference_collection: item.reference_collection,
+								reference_id: item.reference_id,
+								custom_url: item.custom_url,
+								label: item.label,
+								title_attr: item.title_attr,
+								target: item.target,
+								css_classes: item.css_classes,
+								...(input.locale !== undefined ? { locale: input.locale } : {}),
+								translation_group: item.translation_group ?? item.id,
+							})),
+						)
+						.execute();
+				}
+			}
+		});
+
+		const created = await this.findById(id);
+		if (!created) throw new Error("Failed to create menu");
+		return created;
+	}
+
+	async update(id: string, input: UpdateMenuInput): Promise<Menu | null> {
+		const existing = await this.findById(id);
+		if (!existing) return null;
+
+		const values: Record<string, unknown> = {};
+		if (input.label !== undefined) values.label = input.label;
+
+		if (Object.keys(values).length > 0) {
+			await this.db.updateTable("_emdash_menus").set(values).where("id", "=", id).execute();
+		}
+
+		return (await this.findById(id))!;
+	}
+
+	/**
+	 * Delete a menu. Items are deleted explicitly first because D1 disables
+	 * FK enforcement at the database level, so `ON DELETE CASCADE` declared in
+	 * migration 005 cannot be relied on. On SQLite/Postgres the cascade also
+	 * fires, making the explicit delete a no-op there.
+	 */
+	async delete(id: string): Promise<boolean> {
+		const existing = await this.findById(id);
+		if (!existing) return false;
+
+		await withTransaction(this.db, async (trx) => {
+			await trx.deleteFrom("_emdash_menu_items").where("menu_id", "=", id).execute();
+			await trx.deleteFrom("_emdash_menus").where("id", "=", id).execute();
+		});
+		return true;
+	}
+
+	/**
+	 * List every translation of a menu (by id or translation_group).
+	 *
+	 * Returns `null` when neither the id nor the group resolves to a menu,
+	 * mapped to NOT_FOUND by the handler.
+	 */
+	async listTranslations(
+		idOrGroup: string,
+	): Promise<{ translationGroup: string | null; translations: MenuTranslation[] } | null> {
+		const anchor = await this.db
+			.selectFrom("_emdash_menus")
+			.selectAll()
+			.where((eb) => eb.or([eb("id", "=", idOrGroup), eb("translation_group", "=", idOrGroup)]))
+			.executeTakeFirst();
+		if (!anchor) return null;
+
+		const group = anchor.translation_group ?? anchor.id;
+		const rows = await this.db
+			.selectFrom("_emdash_menus")
+			.selectAll()
+			.where("translation_group", "=", group)
+			.orderBy("locale", "asc")
+			.execute();
+
+		return {
+			translationGroup: group,
+			translations: rows.map((row) => ({
+				id: row.id,
+				name: row.name,
+				locale: row.locale,
+				label: row.label,
+				updatedAt: row.updated_at,
+			})),
+		};
+	}
+
+	// --- Items -------------------------------------------------------------
+
+	/**
+	 * Insert a menu item. `locale` is propagated from the parent menu so
+	 * `_emdash_menu_items.locale` mirrors the menu's locale (queries can scope
+	 * by locale without a join).
+	 *
+	 * When `sortOrder` is omitted, the next position within the same parent
+	 * scope is used (max + 1). The fresh `translation_group` defaults to the
+	 * item's own id, matching the migration 036 backfill.
+	 */
+	async createItem(menuId: string, locale: string, input: CreateMenuItemInput): Promise<MenuItem> {
+		let sortOrder = input.sortOrder ?? 0;
+		if (input.sortOrder === undefined) {
+			const maxOrder = await this.db
+				.selectFrom("_emdash_menu_items")
+				.select(({ fn }) => fn.max("sort_order").as("max"))
+				.where("menu_id", "=", menuId)
+				.where("parent_id", "is", input.parentId ?? null)
+				.executeTakeFirst();
+			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Kysely fn.max returns unknown; always a number for sort_order column
+			sortOrder = ((maxOrder?.max as number) ?? -1) + 1;
+		}
+
+		const id = ulid();
+		await this.db
+			.insertInto("_emdash_menu_items")
+			.values({
+				id,
+				menu_id: menuId,
+				parent_id: input.parentId ?? null,
+				sort_order: sortOrder,
+				type: input.type,
+				reference_collection: input.referenceCollection ?? null,
+				reference_id: input.referenceId ?? null,
+				custom_url: input.customUrl ?? null,
+				label: input.label,
+				title_attr: input.titleAttr ?? null,
+				target: input.target ?? null,
+				css_classes: input.cssClasses ?? null,
+				locale,
+				translation_group: id,
+			})
+			.execute();
+
+		const row = await this.db
+			.selectFrom("_emdash_menu_items")
+			.selectAll()
+			.where("id", "=", id)
+			.executeTakeFirstOrThrow();
+		return rowToMenuItem(row);
+	}
+
+	/**
+	 * Update a menu item. Caller must ensure the item belongs to the menu —
+	 * the `where("menu_id", "=", menuId)` guard prevents cross-menu writes.
+	 * Returns `null` if the item is not found within the menu.
+	 */
+	async updateItem(
+		menuId: string,
+		itemId: string,
+		input: UpdateMenuItemInput,
+	): Promise<MenuItem | null> {
+		const existing = await this.db
+			.selectFrom("_emdash_menu_items")
+			.select("id")
+			.where("id", "=", itemId)
+			.where("menu_id", "=", menuId)
+			.executeTakeFirst();
+		if (!existing) return null;
+
+		const values: Record<string, unknown> = {};
+		if (input.label !== undefined) values.label = input.label;
+		if (input.customUrl !== undefined) values.custom_url = input.customUrl;
+		if (input.target !== undefined) values.target = input.target;
+		if (input.titleAttr !== undefined) values.title_attr = input.titleAttr;
+		if (input.cssClasses !== undefined) values.css_classes = input.cssClasses;
+		if (input.parentId !== undefined) values.parent_id = input.parentId;
+		if (input.sortOrder !== undefined) values.sort_order = input.sortOrder;
+
+		if (Object.keys(values).length > 0) {
+			await this.db
+				.updateTable("_emdash_menu_items")
+				.set(values)
+				.where("id", "=", itemId)
+				.execute();
+		}
+
+		const row = await this.db
+			.selectFrom("_emdash_menu_items")
+			.selectAll()
+			.where("id", "=", itemId)
+			.executeTakeFirstOrThrow();
+		return rowToMenuItem(row);
+	}
+
+	/** Delete an item scoped to its menu. Returns false if nothing was deleted. */
+	async deleteItem(menuId: string, itemId: string): Promise<boolean> {
+		const result = await this.db
+			.deleteFrom("_emdash_menu_items")
+			.where("id", "=", itemId)
+			.where("menu_id", "=", menuId)
+			.execute();
+		return result[0]?.numDeletedRows !== 0n;
+	}
+
+	/**
+	 * Atomic replace: delete every existing item and re-insert in order.
+	 * `parentIndex` (validated by the caller) is resolved against the live
+	 * insert order so children always reference real parent ids.
+	 *
+	 * Returns the count of inserted items (matches the existing handler API).
+	 */
+	async setItems(
+		menuId: string,
+		locale: string,
+		items: SetMenuItem[],
+	): Promise<{ itemCount: number }> {
+		await withTransaction(this.db, async (trx) => {
+			// Re-check menu existence INSIDE the transaction. The handler
+			// resolved by (name, locale) before this call; if a concurrent
+			// menu_delete landed in between, inserting new items would
+			// silently orphan them on D1 (where FK enforcement is off, so
+			// the migration's ON DELETE CASCADE never fires). Throw a
+			// MenuGoneError so the rollback fires and the handler returns
+			// NOT_FOUND with the original menu name in the message.
+			const stillThere = await trx
+				.selectFrom("_emdash_menus")
+				.select("id")
+				.where("id", "=", menuId)
+				.executeTakeFirst();
+			if (!stillThere) throw new MenuGoneError(menuId);
+
+			await trx.deleteFrom("_emdash_menu_items").where("menu_id", "=", menuId).execute();
+
+			const insertedIds: string[] = [];
+			for (let i = 0; i < items.length; i++) {
+				const item = items[i];
+				if (!item) continue;
+				const id = ulid();
+				const parentId =
+					item.parentIndex !== undefined ? (insertedIds[item.parentIndex] ?? null) : null;
+				await trx
+					.insertInto("_emdash_menu_items")
+					.values({
+						id,
+						menu_id: menuId,
+						parent_id: parentId,
+						sort_order: i,
+						type: item.type,
+						reference_collection: item.referenceCollection ?? null,
+						reference_id: item.referenceId ?? null,
+						custom_url: item.customUrl ?? null,
+						label: item.label,
+						title_attr: item.titleAttr ?? null,
+						target: item.target ?? null,
+						css_classes: item.cssClasses ?? null,
+						locale,
+					})
+					.execute();
+				insertedIds.push(id);
+			}
+
+			await trx
+				.updateTable("_emdash_menus")
+				.set({ updated_at: new Date().toISOString() })
+				.where("id", "=", menuId)
+				.execute();
+		});
+
+		return { itemCount: items.length };
+	}
+
+	/**
+	 * Batch reorder items. Each entry is applied scoped to the menu so a
+	 * malicious payload cannot move foreign items into this menu's siblings.
+	 */
+	async reorderItems(menuId: string, items: ReorderItem[]): Promise<MenuItem[]> {
+		return withTransaction(this.db, async (trx) => {
+			for (const item of items) {
+				await trx
+					.updateTable("_emdash_menu_items")
+					.set({ parent_id: item.parentId, sort_order: item.sortOrder })
+					.where("id", "=", item.id)
+					.where("menu_id", "=", menuId)
+					.execute();
+			}
+
+			const rows = await trx
+				.selectFrom("_emdash_menu_items")
+				.selectAll()
+				.where("menu_id", "=", menuId)
+				.orderBy("sort_order", "asc")
+				.execute();
+			return rows.map(rowToMenuItem);
+		});
+	}
+}
diff --git a/packages/core/tests/integration/api/menus-handlers.test.ts b/packages/core/tests/integration/api/menus-handlers.test.ts
new file mode 100644
index 000000000..7ea13f996
--- /dev/null
+++ b/packages/core/tests/integration/api/menus-handlers.test.ts
@@ -0,0 +1,280 @@
+/**
+ * Menu handler + schema tests
+ *
+ * Covers the fixes shipped in this PR:
+ * - Input schemas reject unknown keys (snake_case payloads no longer pass silently)
+ * - `type` is validated against the allowed enum
+ * - `customUrl` actually persists when sent under the documented (camelCase) key
+ * - Handler responses are camelCase, aligning with the rest of the REST surface
+ */
+
+import type { Kysely } from "kysely";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import {
+	handleMenuCreate,
+	handleMenuGet,
+	handleMenuItemCreate,
+	handleMenuItemDelete,
+	handleMenuItemUpdate,
+	handleMenuSetItems,
+} from "../../../src/api/handlers/menus.js";
+import { createMenuItemBody, updateMenuItemBody } from "../../../src/api/schemas/menus.js";
+import type { Database } from "../../../src/database/types.js";
+import { setupTestDatabase, teardownTestDatabase } from "../../utils/test-db.js";
+
+describe("menu schemas", () => {
+	describe("createMenuItemBody.strict()", () => {
+		it("rejects snake_case keys (custom_url, sort_order)", () => {
+			const result = createMenuItemBody.safeParse({
+				type: "custom",
+				label: "Blog",
+				custom_url: "/blog",
+				sort_order: 3,
+			});
+			expect(result.success).toBe(false);
+			if (!result.success) {
+				// Zod 4 reports unknown keys with a single `unrecognized_keys`
+				// issue whose `keys` array lists the offending names.
+				const unknownKeys = result.error.issues
+					.filter((i) => i.code === "unrecognized_keys")
+					.flatMap((i) =>
+						"keys" in i && Array.isArray((i as { keys: unknown }).keys)
+							? (i as { keys: string[] }).keys
+							: [],
+					);
+				expect(unknownKeys).toEqual(expect.arrayContaining(["custom_url", "sort_order"]));
+			}
+		});
+
+		it("rejects the legacy `url` alias", () => {
+			const result = createMenuItemBody.safeParse({
+				type: "custom",
+				label: "Blog",
+				url: "/blog",
+			});
+			expect(result.success).toBe(false);
+		});
+
+		it("rejects non-enum `type` values like 'link'", () => {
+			const result = createMenuItemBody.safeParse({
+				type: "link",
+				label: "Blog",
+				customUrl: "/blog",
+			});
+			expect(result.success).toBe(false);
+			if (!result.success) {
+				const typeIssue = result.error.issues.find((i) => i.path[0] === "type");
+				expect(typeIssue).toBeDefined();
+			}
+		});
+
+		it("accepts the documented camelCase payload", () => {
+			const result = createMenuItemBody.safeParse({
+				type: "custom",
+				label: "Blog",
+				customUrl: "/blog",
+				sortOrder: 3,
+			});
+			expect(result.success).toBe(true);
+			if (result.success) {
+				expect(result.data.customUrl).toBe("/blog");
+				expect(result.data.sortOrder).toBe(3);
+			}
+		});
+	});
+
+	describe("updateMenuItemBody.strict()", () => {
+		it("rejects snake_case keys on update too", () => {
+			const result = updateMenuItemBody.safeParse({ custom_url: "/x" });
+			expect(result.success).toBe(false);
+		});
+	});
+});
+
+describe("menu handlers — camelCase responses & customUrl persistence", () => {
+	let db: Kysely<Database>;
+
+	beforeEach(async () => {
+		db = await setupTestDatabase();
+	});
+
+	afterEach(async () => {
+		await teardownTestDatabase(db);
+	});
+
+	it("handleMenuCreate returns a camelCase Menu", async () => {
+		const result = await handleMenuCreate(db, { name: "primary", label: "Primary" });
+		expect(result.success).toBe(true);
+		if (result.success) {
+			expect(result.data).toMatchObject({
+				name: "primary",
+				label: "Primary",
+				locale: "en",
+			});
+			expect(result.data.createdAt).toEqual(expect.any(String));
+			expect(result.data.updatedAt).toEqual(expect.any(String));
+			expect(result.data.translationGroup).toBeDefined();
+			expect(result.data).not.toHaveProperty("created_at");
+			expect(result.data).not.toHaveProperty("updated_at");
+			expect(result.data).not.toHaveProperty("translation_group");
+		}
+	});
+
+	it("handleMenuItemCreate persists customUrl and returns camelCase", async () => {
+		const menuRes = await handleMenuCreate(db, { name: "primary", label: "Primary" });
+		expect(menuRes.success).toBe(true);
+
+		const itemRes = await handleMenuItemCreate(db, "primary", {
+			type: "custom",
+			label: "Blog",
+			customUrl: "/blog",
+			sortOrder: 0,
+		});
+		expect(itemRes.success).toBe(true);
+		if (itemRes.success) {
+			// camelCase response shape
+			expect(itemRes.data).toMatchObject({
+				type: "custom",
+				label: "Blog",
+				customUrl: "/blog",
+				sortOrder: 0,
+			});
+			expect(itemRes.data.menuId).toEqual(expect.any(String));
+			expect(itemRes.data.createdAt).toEqual(expect.any(String));
+			expect(itemRes.data).not.toHaveProperty("custom_url");
+			expect(itemRes.data).not.toHaveProperty("sort_order");
+			expect(itemRes.data).not.toHaveProperty("menu_id");
+			expect(itemRes.data).not.toHaveProperty("translation_group");
+		}
+
+		// And the persisted DB row still has the snake_case column populated
+		const getRes = await handleMenuGet(db, "primary");
+		expect(getRes.success).toBe(true);
+		if (getRes.success) {
+			expect(getRes.data.items).toHaveLength(1);
+			expect(getRes.data.items[0]).toMatchObject({
+				label: "Blog",
+				customUrl: "/blog",
+				type: "custom",
+			});
+		}
+	});
+
+	it("handleMenuItemUpdate returns camelCase and supports customUrl edits", async () => {
+		await handleMenuCreate(db, { name: "primary", label: "Primary" });
+		const created = await handleMenuItemCreate(db, "primary", {
+			type: "custom",
+			label: "Blog",
+			customUrl: "/blog",
+		});
+		expect(created.success).toBe(true);
+		if (!created.success) return;
+
+		const updated = await handleMenuItemUpdate(db, "primary", created.data.id, {
+			customUrl: "/new-blog",
+		});
+		expect(updated.success).toBe(true);
+		if (updated.success) {
+			expect(updated.data.customUrl).toBe("/new-blog");
+			expect(updated.data).not.toHaveProperty("custom_url");
+		}
+	});
+
+	it("handleMenuItemDelete removes the item and returns { deleted: true }", async () => {
+		await handleMenuCreate(db, { name: "primary", label: "Primary" });
+		const created = await handleMenuItemCreate(db, "primary", {
+			type: "custom",
+			label: "Blog",
+			customUrl: "/blog",
+		});
+		expect(created.success).toBe(true);
+		if (!created.success) return;
+
+		const del = await handleMenuItemDelete(db, "primary", created.data.id);
+		expect(del.success).toBe(true);
+		if (del.success) expect(del.data.deleted).toBe(true);
+
+		const after = await handleMenuGet(db, "primary");
+		expect(after.success).toBe(true);
+		if (after.success) expect(after.data.items).toHaveLength(0);
+	});
+
+	it("handleMenuGet returns camelCase menu and items", async () => {
+		await handleMenuCreate(db, { name: "primary", label: "Primary" });
+		await handleMenuItemCreate(db, "primary", {
+			type: "custom",
+			label: "Blog",
+			customUrl: "/blog",
+		});
+
+		const res = await handleMenuGet(db, "primary");
+		expect(res.success).toBe(true);
+		if (res.success) {
+			expect(res.data.createdAt).toEqual(expect.any(String));
+			expect(res.data.translationGroup).toBeDefined();
+			expect(res.data).not.toHaveProperty("created_at");
+			expect(res.data.items).toHaveLength(1);
+			expect(res.data.items[0].customUrl).toBe("/blog");
+			expect(res.data.items[0]).not.toHaveProperty("custom_url");
+		}
+	});
+});
+
+describe("handleMenuSetItems — concurrent delete race", () => {
+	let db: Kysely<Database>;
+
+	beforeEach(async () => {
+		db = await setupTestDatabase();
+	});
+
+	afterEach(async () => {
+		await teardownTestDatabase(db);
+	});
+
+	it("returns NOT_FOUND when the menu vanishes between resolve and write", async () => {
+		// The original handler's in-transaction `notFoundSentinel` guarded
+		// this exact race: a concurrent menu_delete between resolveMenu and
+		// the setItems INSERTs would otherwise orphan items on D1.
+		const createRes = await handleMenuCreate(db, { name: "primary", label: "Primary" });
+		expect(createRes.success).toBe(true);
+		if (!createRes.success) return;
+		const menuId = createRes.data.id;
+
+		// Simulate the concurrent delete that lands between the handler's
+		// resolveMenu lookup and the repository's transaction. We delete
+		// directly through Kysely (handlers can't be paused mid-flight).
+		await db.deleteFrom("_emdash_menu_items").where("menu_id", "=", menuId).execute();
+		await db.deleteFrom("_emdash_menus").where("id", "=", menuId).execute();
+
+		const result = await handleMenuSetItems(db, "primary", [
+			{ label: "Orphan?", type: "custom", customUrl: "/orphan" },
+		]);
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			expect(result.error.code).toBe("NOT_FOUND");
+			expect(result.error.message).toContain("primary");
+		}
+
+		// Nothing was inserted — no orphans.
+		const orphans = await db
+			.selectFrom("_emdash_menu_items")
+			.selectAll()
+			.where("menu_id", "=", menuId)
+			.execute();
+		expect(orphans).toHaveLength(0);
+	});
+});
+
+describe("menu items path-style route", () => {
+	it("exposes a [name]/items/[id].ts route file", async () => {
+		// The presence of the file (path-style) is what makes the documented
+		// REST-style DELETE /items/:id reachable; without it Astro returns the
+		// SSR 404 HTML page. We import dynamically to assert the module exists
+		// and exports the expected HTTP verbs.
+		const mod = await import("../../../src/astro/routes/api/menus/[name]/items/[id].js");
+		expect(typeof mod.PUT).toBe("function");
+		expect(typeof mod.DELETE).toBe("function");
+		expect(mod.prerender).toBe(false);
+	});
+});
diff --git a/packages/core/tests/integration/database/menu-repository.test.ts b/packages/core/tests/integration/database/menu-repository.test.ts
new file mode 100644
index 000000000..97855742f
--- /dev/null
+++ b/packages/core/tests/integration/database/menu-repository.test.ts
@@ -0,0 +1,398 @@
+/**
+ * MenuRepository — repository-level tests
+ *
+ * Mirrors the coverage style of the other repository test suites
+ * (`redirect-handlers.test.ts`, `taxonomy.test.ts`, etc.). The repository is
+ * the single layer responsible for snake_case ↔ camelCase mapping and for
+ * cross-table operations (translation cloning, atomic set-items, delete with
+ * explicit item cleanup for D1 safety).
+ */
+
+import type { Kysely } from "kysely";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { MenuGoneError, MenuRepository } from "../../../src/database/repositories/menu.js";
+import type { Database } from "../../../src/database/types.js";
+import { setupTestDatabase, teardownTestDatabase } from "../../utils/test-db.js";
+
+describe("MenuRepository", () => {
+	let db: Kysely<Database>;
+	let repo: MenuRepository;
+
+	beforeEach(async () => {
+		db = await setupTestDatabase();
+		repo = new MenuRepository(db);
+	});
+
+	afterEach(async () => {
+		await teardownTestDatabase(db);
+	});
+
+	describe("row → entity mapping", () => {
+		it("create() returns a camelCase Menu", async () => {
+			const menu = await repo.create({ name: "primary", label: "Primary" });
+			expect(menu).toMatchObject({ name: "primary", label: "Primary", locale: "en" });
+			expect(typeof menu.createdAt).toBe("string");
+			expect(typeof menu.updatedAt).toBe("string");
+			expect(menu.translationGroup).toBe(menu.id);
+			// no leakage of snake_case keys
+			expect(menu).not.toHaveProperty("created_at");
+			expect(menu).not.toHaveProperty("updated_at");
+			expect(menu).not.toHaveProperty("translation_group");
+		});
+
+		it("createItem() returns a camelCase MenuItem", async () => {
+			const menu = await repo.create({ name: "primary", label: "Primary" });
+			const item = await repo.createItem(menu.id, menu.locale, {
+				type: "custom",
+				label: "Blog",
+				customUrl: "/blog",
+			});
+			expect(item).toMatchObject({
+				menuId: menu.id,
+				type: "custom",
+				label: "Blog",
+				customUrl: "/blog",
+				sortOrder: 0,
+				parentId: null,
+			});
+			expect(item.translationGroup).toBe(item.id);
+			expect(item).not.toHaveProperty("custom_url");
+			expect(item).not.toHaveProperty("menu_id");
+			expect(item).not.toHaveProperty("sort_order");
+		});
+	});
+
+	describe("findMany() — list with item counts", () => {
+		it("returns 0 when there are no items", async () => {
+			await repo.create({ name: "primary", label: "Primary" });
+			const rows = await repo.findMany();
+			expect(rows).toHaveLength(1);
+			expect(rows[0]!.itemCount).toBe(0);
+		});
+
+		it("counts items correctly", async () => {
+			const menu = await repo.create({ name: "primary", label: "Primary" });
+			await repo.createItem(menu.id, menu.locale, { type: "custom", label: "A", customUrl: "/a" });
+			await repo.createItem(menu.id, menu.locale, { type: "custom", label: "B", customUrl: "/b" });
+			const rows = await repo.findMany();
+			expect(rows[0]!.itemCount).toBe(2);
+		});
+
+		it("filters by locale when supplied", async () => {
+			await repo.create({ name: "primary", label: "Primary" });
+			await repo.create({ name: "primary", label: "Principal", locale: "es" });
+			const all = await repo.findMany();
+			expect(all).toHaveLength(2);
+			const en = await repo.findMany({ locale: "en" });
+			expect(en).toHaveLength(1);
+			expect(en[0]!.locale).toBe("en");
+		});
+	});
+
+	describe("findByName()", () => {
+		it("returns multiple rows when the same name has translations", async () => {
+			const src = await repo.create({ name: "primary", label: "Primary" });
+			await repo.create({
+				name: "primary",
+				label: "Principal",
+				locale: "es",
+				translationOf: src.id,
+			});
+			const both = await repo.findByName("primary");
+			expect(both).toHaveLength(2);
+			expect(both.map((m) => m.locale).toSorted()).toEqual(["en", "es"]);
+		});
+
+		it("scopes by locale when supplied", async () => {
+			const src = await repo.create({ name: "primary", label: "Primary" });
+			await repo.create({
+				name: "primary",
+				label: "Principal",
+				locale: "es",
+				translationOf: src.id,
+			});
+			const es = await repo.findByName("primary", { locale: "es" });
+			expect(es).toHaveLength(1);
+			expect(es[0]!.locale).toBe("es");
+		});
+	});
+
+	describe("create() with translationOf", () => {
+		it("clones items into the new locale and shares translation_group", async () => {
+			const src = await repo.create({ name: "primary", label: "Primary" });
+			await repo.createItem(src.id, src.locale, { type: "custom", label: "Home", customUrl: "/" });
+			await repo.createItem(src.id, src.locale, {
+				type: "custom",
+				label: "About",
+				customUrl: "/about",
+			});
+
+			const target = await repo.create({
+				name: "primary",
+				label: "Principal",
+				locale: "es",
+				translationOf: src.id,
+			});
+
+			expect(target.translationGroup).toBe(src.translationGroup);
+
+			const items = await repo.findItems(target.id);
+			expect(items).toHaveLength(2);
+			expect(items.map((i) => i.label)).toEqual(["Home", "About"]);
+			expect(items.every((i) => i.locale === "es")).toBe(true);
+			// Each cloned item shares the source item's translation_group so the
+			// nav entry is treated as "the same logical item" across translations.
+			const srcItems = await repo.findItems(src.id);
+			const srcGroupsByLabel = new Map(srcItems.map((i) => [i.label, i.translationGroup]));
+			for (const cloned of items) {
+				expect(cloned.translationGroup).toBe(srcGroupsByLabel.get(cloned.label));
+			}
+		});
+
+		it("throws when the source menu doesn't exist", async () => {
+			await expect(
+				repo.create({
+					name: "primary",
+					label: "Principal",
+					locale: "es",
+					translationOf: "01XXNOTREALXXXXXXXXXXXXXXX",
+				}),
+			).rejects.toThrow(/source/i);
+		});
+	});
+
+	describe("delete() removes items first (D1-safe)", () => {
+		it("deletes a menu and all its items", async () => {
+			const menu = await repo.create({ name: "primary", label: "Primary" });
+			await repo.createItem(menu.id, menu.locale, {
+				type: "custom",
+				label: "Home",
+				customUrl: "/",
+			});
+			expect(await repo.findItems(menu.id)).toHaveLength(1);
+
+			const deleted = await repo.delete(menu.id);
+			expect(deleted).toBe(true);
+
+			// No menu left, no orphaned items in the table either.
+			expect(await repo.findById(menu.id)).toBeNull();
+			const orphans = await db
+				.selectFrom("_emdash_menu_items")
+				.selectAll()
+				.where("menu_id", "=", menu.id)
+				.execute();
+			expect(orphans).toHaveLength(0);
+		});
+
+		it("returns false when the menu doesn't exist", async () => {
+			const deleted = await repo.delete("01XXNOTREALXXXXXXXXXXXXXXX");
+			expect(deleted).toBe(false);
+		});
+	});
+
+	describe("createItem() default sortOrder", () => {
+		it("appends with the next available sortOrder when omitted", async () => {
+			const menu = await repo.create({ name: "primary", label: "Primary" });
+			const a = await repo.createItem(menu.id, menu.locale, {
+				type: "custom",
+				label: "A",
+				customUrl: "/a",
+			});
+			const b = await repo.createItem(menu.id, menu.locale, {
+				type: "custom",
+				label: "B",
+				customUrl: "/b",
+			});
+			expect(a.sortOrder).toBe(0);
+			expect(b.sortOrder).toBe(1);
+		});
+
+		it("calculates sortOrder per parent scope", async () => {
+			const menu = await repo.create({ name: "primary", label: "Primary" });
+			const parent = await repo.createItem(menu.id, menu.locale, {
+				type: "custom",
+				label: "Parent",
+				customUrl: "/p",
+			});
+			const child1 = await repo.createItem(menu.id, menu.locale, {
+				type: "custom",
+				label: "C1",
+				customUrl: "/p/1",
+				parentId: parent.id,
+			});
+			const child2 = await repo.createItem(menu.id, menu.locale, {
+				type: "custom",
+				label: "C2",
+				customUrl: "/p/2",
+				parentId: parent.id,
+			});
+			expect(child1.sortOrder).toBe(0);
+			expect(child2.sortOrder).toBe(1);
+		});
+	});
+
+	describe("updateItem()", () => {
+		it("returns null when the item doesn't belong to the menu", async () => {
+			const menu1 = await repo.create({ name: "primary", label: "Primary" });
+			const menu2 = await repo.create({ name: "footer", label: "Footer" });
+			const item = await repo.createItem(menu2.id, menu2.locale, {
+				type: "custom",
+				label: "A",
+				customUrl: "/a",
+			});
+			// Try to update menu2's item via menu1.id — should fail.
+			const result = await repo.updateItem(menu1.id, item.id, { customUrl: "/hijacked" });
+			expect(result).toBeNull();
+			// And the original value is untouched.
+			const items = await repo.findItems(menu2.id);
+			expect(items[0]!.customUrl).toBe("/a");
+		});
+
+		it("persists customUrl updates and keeps the camelCase shape", async () => {
+			const menu = await repo.create({ name: "primary", label: "Primary" });
+			const item = await repo.createItem(menu.id, menu.locale, {
+				type: "custom",
+				label: "Blog",
+				customUrl: "/blog",
+			});
+			const updated = await repo.updateItem(menu.id, item.id, { customUrl: "/new-blog" });
+			expect(updated?.customUrl).toBe("/new-blog");
+			expect(updated).not.toHaveProperty("custom_url");
+		});
+	});
+
+	describe("deleteItem()", () => {
+		it("scopes the delete by menu_id", async () => {
+			const a = await repo.create({ name: "primary", label: "Primary" });
+			const b = await repo.create({ name: "footer", label: "Footer" });
+			const item = await repo.createItem(b.id, b.locale, {
+				type: "custom",
+				label: "X",
+				customUrl: "/x",
+			});
+
+			// Attempting to delete it through the wrong menu should be a no-op.
+			expect(await repo.deleteItem(a.id, item.id)).toBe(false);
+			expect((await repo.findItems(b.id)).length).toBe(1);
+
+			// Through the correct menu it deletes.
+			expect(await repo.deleteItem(b.id, item.id)).toBe(true);
+			expect((await repo.findItems(b.id)).length).toBe(0);
+		});
+	});
+
+	describe("setItems()", () => {
+		it("replaces existing items atomically and resolves parentIndex", async () => {
+			const menu = await repo.create({ name: "primary", label: "Primary" });
+			await repo.createItem(menu.id, menu.locale, {
+				type: "custom",
+				label: "Old",
+				customUrl: "/old",
+			});
+
+			const { itemCount } = await repo.setItems(menu.id, menu.locale, [
+				{ label: "Root", type: "custom", customUrl: "/" },
+				{ label: "Child", type: "custom", customUrl: "/child", parentIndex: 0 },
+				{ label: "Grandchild", type: "custom", customUrl: "/gc", parentIndex: 1 },
+			]);
+			expect(itemCount).toBe(3);
+
+			const items = await repo.findItems(menu.id);
+			expect(items.map((i) => i.label)).toEqual(["Root", "Child", "Grandchild"]);
+			const byLabel = new Map(items.map((i) => [i.label, i]));
+			expect(byLabel.get("Root")!.parentId).toBeNull();
+			expect(byLabel.get("Child")!.parentId).toBe(byLabel.get("Root")!.id);
+			expect(byLabel.get("Grandchild")!.parentId).toBe(byLabel.get("Child")!.id);
+		});
+
+		it("throws MenuGoneError when the menu disappears mid-flight (concurrent delete)", async () => {
+			// Simulates the race that the original handler's in-transaction
+			// `notFoundSentinel` guarded against: another caller deletes the
+			// menu between the handler's `resolveMenu` lookup and the
+			// repository's destructive setItems write. Without the in-tx
+			// existence check we'd happily insert orphan items on D1 (FKs off).
+			const menu = await repo.create({ name: "primary", label: "Primary" });
+			// Delete the menu's row (and any items) to mimic the racing call.
+			await db.deleteFrom("_emdash_menu_items").where("menu_id", "=", menu.id).execute();
+			await db.deleteFrom("_emdash_menus").where("id", "=", menu.id).execute();
+
+			await expect(
+				repo.setItems(menu.id, "en", [{ label: "Stray", type: "custom", customUrl: "/stray" }]),
+			).rejects.toBeInstanceOf(MenuGoneError);
+
+			// No orphan items left behind by the aborted transaction.
+			const orphans = await db
+				.selectFrom("_emdash_menu_items")
+				.selectAll()
+				.where("menu_id", "=", menu.id)
+				.execute();
+			expect(orphans).toHaveLength(0);
+		});
+
+		it("touches updated_at on the menu", async () => {
+			const menu = await repo.create({ name: "primary", label: "Primary" });
+			const before = (await repo.findById(menu.id))!.updatedAt;
+			// Force a measurable gap so timestamp resolution doesn't flake.
+			await new Promise((r) => setTimeout(r, 10));
+			await repo.setItems(menu.id, menu.locale, [{ label: "X", type: "custom", customUrl: "/x" }]);
+			const after = (await repo.findById(menu.id))!.updatedAt;
+			expect(after >= before).toBe(true);
+		});
+	});
+
+	describe("reorderItems()", () => {
+		it("ignores updates that target items outside the menu", async () => {
+			const a = await repo.create({ name: "primary", label: "Primary" });
+			const b = await repo.create({ name: "footer", label: "Footer" });
+			const aItem = await repo.createItem(a.id, a.locale, {
+				type: "custom",
+				label: "A",
+				customUrl: "/a",
+			});
+			const bItem = await repo.createItem(b.id, b.locale, {
+				type: "custom",
+				label: "B",
+				customUrl: "/b",
+			});
+
+			// Pass the foreign item id through menu A's reorder — it should be
+			// silently ignored (the where("menu_id", "=", a.id) guard rejects it).
+			await repo.reorderItems(a.id, [
+				{ id: aItem.id, parentId: null, sortOrder: 5 },
+				{ id: bItem.id, parentId: null, sortOrder: 99 },
+			]);
+
+			const aItems = await repo.findItems(a.id);
+			const bItems = await repo.findItems(b.id);
+			expect(aItems[0]!.sortOrder).toBe(5);
+			expect(bItems[0]!.sortOrder).toBe(0); // unchanged
+		});
+	});
+
+	describe("listTranslations()", () => {
+		it("returns every translation in the group", async () => {
+			const src = await repo.create({ name: "primary", label: "Primary" });
+			await repo.create({
+				name: "primary",
+				label: "Principal",
+				locale: "es",
+				translationOf: src.id,
+			});
+
+			const byId = await repo.listTranslations(src.id);
+			expect(byId).not.toBeNull();
+			expect(byId!.translationGroup).toBe(src.translationGroup);
+			expect(byId!.translations).toHaveLength(2);
+			expect(byId!.translations.map((t) => t.locale).toSorted()).toEqual(["en", "es"]);
+
+			const byGroup = await repo.listTranslations(src.translationGroup!);
+			expect(byGroup!.translations).toHaveLength(2);
+		});
+
+		it("returns null when neither id nor group matches", async () => {
+			const result = await repo.listTranslations("01XXNOTREALXXXXXXXXXXXXXXX");
+			expect(result).toBeNull();
+		});
+	});
+});
diff --git a/packages/core/tests/integration/mcp/menu.test.ts b/packages/core/tests/integration/mcp/menu.test.ts
index d6e8ae324..7c96019b3 100644
--- a/packages/core/tests/integration/mcp/menu.test.ts
+++ b/packages/core/tests/integration/mcp/menu.test.ts
@@ -184,7 +184,7 @@ describe("menu_get", () => {
 		expect(result.isError, extractText(result)).toBeFalsy();
 		const menu = extractJson<{
 			name: string;
-			items: Array<{ label: string; sort_order: number }>;
+			items: Array<{ label: string; sortOrder: number }>;
 		}>(result);
 		expect(menu.name).toBe("main");
 		expect(menu.items).toHaveLength(3);
@@ -504,7 +504,7 @@ describe("menu mutations (bug #15 / F6 / F12)", () => {
 			arguments: { name: "main" },
 		});
 		const menu = extractJson<{
-			items: Array<{ id: string; label: string; parent_id: string | null; sort_order: number }>;
+			items: Array<{ id: string; label: string; parentId: string | null; sortOrder: number }>;
 		}>(get);
 		expect(menu.items).toHaveLength(3);
 
@@ -512,9 +512,9 @@ describe("menu mutations (bug #15 / F6 / F12)", () => {
 		const root = byLabel.get("Root");
 		const child = byLabel.get("Child");
 		const grand = byLabel.get("Grandchild");
-		expect(root?.parent_id).toBeNull();
-		expect(child?.parent_id).toBe(root?.id);
-		expect(grand?.parent_id).toBe(child?.id);
+		expect(root?.parentId).toBeNull();
+		expect(child?.parentId).toBe(root?.id);
+		expect(grand?.parentId).toBe(child?.id);
 	});
 
 	it("menu_set_items rejects parentIndex >= i (must be earlier)", async () => {