emdash 0.9.0 → 0.10.0

package/src/astro/routes/api/menus/[name]/translations.ts

@@ -0,0 +1,82 @@
+/**
+ * Menu translation endpoints
+ *
+ * GET  /_emdash/api/menus/:name/translations       — list translations for a menu (uses any locale row)
+ * POST /_emdash/api/menus/:name/translations       — create a new locale translation (body: { locale, label })
+ */
+
+import type { APIRoute } from "astro";
+import { z } from "zod";
+
+import { requirePerm } from "#api/authorize.js";
+import { handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleMenuCreate, handleMenuGet, handleMenuTranslations } from "#api/handlers/menus.js";
+import { isParseError, parseBody, parseQuery } from "#api/parse.js";
+import { localeFilterQuery } from "#api/schemas.js";
+
+export const prerender = false;
+
+const createTranslationBody = z
+	.object({
+		locale: z.string().min(1),
+		label: z.string().min(1).optional(),
+	})
+	.meta({ id: "CreateMenuTranslationBody" });
+
+export const GET: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const name = params.name!;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "menus:read");
+	if (denied) return denied;
+
+	const localeQ = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
+
+	try {
+		// Look up any menu row matching the name so we can get its translation_group.
+		const anchor = await handleMenuGet(emdash.db, name, { locale: localeQ.locale });
+		if (!anchor.success) return unwrapResult(anchor);
+		const result = await handleMenuTranslations(emdash.db, anchor.data.id);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to fetch menu translations", "MENU_TRANSLATIONS_ERROR");
+	}
+};
+
+export const POST: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const name = params.name!;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "menus:manage");
+	if (denied) return denied;
+
+	const localeQ = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(localeQ)) return localeQ;
+
+	try {
+		const body = await parseBody(request, createTranslationBody);
+		if (isParseError(body)) return body;
+
+		// Resolve the source menu (either by explicit locale in query, or the
+		// first matching row). Its id becomes the `translationOf` for the new row.
+		const source = await handleMenuGet(emdash.db, name, { locale: localeQ.locale });
+		if (!source.success) return unwrapResult(source);
+
+		const result = await handleMenuCreate(emdash.db, {
+			name,
+			label: body.label ?? source.data.label,
+			locale: body.locale,
+			translationOf: source.data.id,
+		});
+		return unwrapResult(result, 201);
+	} catch (error) {
+		return handleError(error, "Failed to create menu translation", "MENU_TRANSLATION_CREATE_ERROR");
+	}
+};

package/src/astro/routes/api/menus/[name].ts

@@ -1,9 +1,9 @@
 /**
  * Single menu endpoint
  *
- * GET    /_emdash/api/menus/:name - Get menu with items
- * PUT    /_emdash/api/menus/:name - Update menu metadata
- * DELETE /_emdash/api/menus/:name - Delete menu
+ * GET    /_emdash/api/menus/:name[?locale=xx]
+ * PUT    /_emdash/api/menus/:name[?locale=xx]
+ * DELETE /_emdash/api/menus/:name[?locale=xx]
  */
 
 import type { APIRoute } from "astro";
@@ -11,20 +11,23 @@ import type { APIRoute } from "astro";
 import { requirePerm } from "#api/authorize.js";
 import { handleError, unwrapResult } from "#api/error.js";
 import { handleMenuDelete, handleMenuGet, handleMenuUpdate } from "#api/handlers/menus.js";
-import { isParseError, parseBody } from "#api/parse.js";
-import { updateMenuBody } from "#api/schemas.js";
+import { isParseError, parseBody, parseQuery } from "#api/parse.js";
+import { localeFilterQuery, updateMenuBody } from "#api/schemas.js";
 
 export const prerender = false;
 
-export const GET: APIRoute = async ({ params, locals }) => {
+export const GET: APIRoute = async ({ params, request, locals }) => {
 	const { emdash, user } = locals;
 	const name = params.name!;
 
 	const denied = requirePerm(user, "menus:read");
 	if (denied) return denied;
 
+	const query = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(query)) return query;
+
 	try {
-		const result = await handleMenuGet(emdash.db, name);
+		const result = await handleMenuGet(emdash.db, name, { locale: query.locale });
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to fetch menu", "MENU_GET_ERROR");
@@ -38,26 +41,32 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 	const denied = requirePerm(user, "menus:manage");
 	if (denied) return denied;
 
+	const query = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(query)) return query;
+
 	try {
 		const body = await parseBody(request, updateMenuBody);
 		if (isParseError(body)) return body;
 
-		const result = await handleMenuUpdate(emdash.db, name, body);
+		const result = await handleMenuUpdate(emdash.db, name, { ...body, locale: query.locale });
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to update menu", "MENU_UPDATE_ERROR");
 	}
 };
 
-export const DELETE: APIRoute = async ({ params, locals }) => {
+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 query = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(query)) return query;
+
 	try {
-		const result = await handleMenuDelete(emdash.db, name);
+		const result = await handleMenuDelete(emdash.db, name, { locale: query.locale });
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to delete menu", "MENU_DELETE_ERROR");

package/src/astro/routes/api/menus/index.ts

@@ -1,8 +1,8 @@
 /**
  * Menus list and create endpoints
  *
- * GET  /_emdash/api/menus - List all menus
- * POST /_emdash/api/menus - Create menu
+ * GET  /_emdash/api/menus[?locale=xx] - List menus (optionally filtered by locale)
+ * POST /_emdash/api/menus              - Create menu (body may include locale & translationOf)
  */
 
 import type { APIRoute } from "astro";
@@ -10,19 +10,22 @@ import type { APIRoute } from "astro";
 import { requirePerm } from "#api/authorize.js";
 import { handleError, unwrapResult } from "#api/error.js";
 import { handleMenuCreate, handleMenuList } from "#api/handlers/menus.js";
-import { isParseError, parseBody } from "#api/parse.js";
-import { createMenuBody } from "#api/schemas.js";
+import { isParseError, parseBody, parseQuery } from "#api/parse.js";
+import { createMenuBody, localeFilterQuery } from "#api/schemas.js";
 
 export const prerender = false;
 
-export const GET: APIRoute = async ({ locals }) => {
+export const GET: APIRoute = async ({ request, locals }) => {
 	const { emdash, user } = locals;
 
 	const denied = requirePerm(user, "menus:read");
 	if (denied) return denied;
 
+	const query = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(query)) return query;
+
 	try {
-		const result = await handleMenuList(emdash.db);
+		const result = await handleMenuList(emdash.db, { locale: query.locale });
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to fetch menus", "MENU_LIST_ERROR");

package/src/astro/routes/api/taxonomies/[name]/terms/[slug]/translations.ts

@@ -0,0 +1,89 @@
+/**
+ * Term translation endpoints
+ *
+ * GET  /_emdash/api/taxonomies/:name/terms/:slug/translations[?locale=xx]
+ * POST /_emdash/api/taxonomies/:name/terms/:slug/translations
+ *    body: { locale, label?, slug? }
+ */
+
+import type { APIRoute } from "astro";
+import { z } from "zod";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
+import {
+	handleTermCreate,
+	handleTermGet,
+	handleTermTranslations,
+} from "#api/handlers/taxonomies.js";
+import { isParseError, parseBody, parseQuery } from "#api/parse.js";
+import { localeFilterQuery } from "#api/schemas.js";
+
+export const prerender = false;
+
+const createTermTranslationBody = z
+	.object({
+		locale: z.string().min(1),
+		label: z.string().min(1).optional(),
+		slug: z.string().min(1).optional(),
+	})
+	.meta({ id: "CreateTermTranslationBody" });
+
+export const GET: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const { name, slug } = params;
+	if (!name || !slug) return apiError("VALIDATION_ERROR", "Taxonomy name and slug required", 400);
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "taxonomies:read");
+	if (denied) return denied;
+
+	const query = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(query)) return query;
+
+	try {
+		const anchor = await handleTermGet(emdash.db, name, slug, { locale: query.locale });
+		if (!anchor.success) return unwrapResult(anchor);
+		const result = await handleTermTranslations(emdash.db, anchor.data.term.id);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to list term translations", "TERM_TRANSLATIONS_ERROR");
+	}
+};
+
+export const POST: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const { name, slug } = params;
+	if (!name || !slug) return apiError("VALIDATION_ERROR", "Taxonomy name and slug required", 400);
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "taxonomies:manage");
+	if (denied) return denied;
+
+	const query = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(query)) return query;
+
+	try {
+		const body = await parseBody(request, createTermTranslationBody);
+		if (isParseError(body)) return body;
+
+		const source = await handleTermGet(emdash.db, name, slug, { locale: query.locale });
+		if (!source.success) return unwrapResult(source);
+
+		const result = await handleTermCreate(emdash.db, name, {
+			slug: body.slug ?? source.data.term.slug,
+			label: body.label ?? source.data.term.label,
+			parentId: source.data.term.parentId,
+			description: source.data.term.description,
+			locale: body.locale,
+			translationOf: source.data.term.id,
+		});
+		return unwrapResult(result, 201);
+	} catch (error) {
+		return handleError(error, "Failed to create term translation", "TERM_TRANSLATION_CREATE_ERROR");
+	}
+};

package/src/astro/routes/api/taxonomies/[name]/terms/[slug].ts

@@ -1,9 +1,9 @@
 /**
  * Single term endpoint
  *
- * GET /_emdash/api/taxonomies/:name/terms/:slug - Get a single term
- * PUT /_emdash/api/taxonomies/:name/terms/:slug - Update a term
- * DELETE /_emdash/api/taxonomies/:name/terms/:slug - Delete a term
+ * GET    /_emdash/api/taxonomies/:name/terms/:slug[?locale=xx]
+ * PUT    /_emdash/api/taxonomies/:name/terms/:slug[?locale=xx]
+ * DELETE /_emdash/api/taxonomies/:name/terms/:slug[?locale=xx]
  */
 
 import type { APIRoute } from "astro";
@@ -11,21 +11,18 @@ import type { APIRoute } from "astro";
 import { requirePerm } from "#api/authorize.js";
 import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
 import { handleTermDelete, handleTermGet, handleTermUpdate } from "#api/handlers/taxonomies.js";
-import { isParseError, parseBody } from "#api/parse.js";
-import { updateTermBody } from "#api/schemas.js";
+import { isParseError, parseBody, parseQuery } from "#api/parse.js";
+import { localeFilterQuery, updateTermBody } from "#api/schemas.js";
 
 export const prerender = false;
 
 /**
  * Get a single term
  */
-export const GET: APIRoute = async ({ params, locals }) => {
+export const GET: APIRoute = async ({ params, request, locals }) => {
 	const { emdash, user } = locals;
 	const { name, slug } = params;
-
-	if (!name || !slug) {
-		return apiError("VALIDATION_ERROR", "Taxonomy name and slug required", 400);
-	}
+	if (!name || !slug) return apiError("VALIDATION_ERROR", "Taxonomy name and slug required", 400);
 
 	const dbErr = requireDb(emdash?.db);
 	if (dbErr) return dbErr;
@@ -33,8 +30,11 @@ export const GET: APIRoute = async ({ params, locals }) => {
 	const denied = requirePerm(user, "taxonomies:read");
 	if (denied) return denied;
 
+	const query = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(query)) return query;
+
 	try {
-		const result = await handleTermGet(emdash.db, name, slug);
+		const result = await handleTermGet(emdash.db, name, slug, { locale: query.locale });
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to get term", "TERM_GET_ERROR");
@@ -47,10 +47,7 @@ export const GET: APIRoute = async ({ params, locals }) => {
 export const PUT: APIRoute = async ({ params, request, locals }) => {
 	const { emdash, user } = locals;
 	const { name, slug } = params;
-
-	if (!name || !slug) {
-		return apiError("VALIDATION_ERROR", "Taxonomy name and slug required", 400);
-	}
+	if (!name || !slug) return apiError("VALIDATION_ERROR", "Taxonomy name and slug required", 400);
 
 	const dbErr = requireDb(emdash?.db);
 	if (dbErr) return dbErr;
@@ -58,11 +55,14 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 	const denied = requirePerm(user, "taxonomies:manage");
 	if (denied) return denied;
 
+	const query = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(query)) return query;
+
 	try {
 		const body = await parseBody(request, updateTermBody);
 		if (isParseError(body)) return body;
 
-		const result = await handleTermUpdate(emdash.db, name, slug, body);
+		const result = await handleTermUpdate(emdash.db, name, slug, body, { locale: query.locale });
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to update term", "TERM_UPDATE_ERROR");
@@ -72,13 +72,10 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 /**
  * Delete a term
  */
-export const DELETE: APIRoute = async ({ params, locals }) => {
+export const DELETE: APIRoute = async ({ params, request, locals }) => {
 	const { emdash, user } = locals;
 	const { name, slug } = params;
-
-	if (!name || !slug) {
-		return apiError("VALIDATION_ERROR", "Taxonomy name and slug required", 400);
-	}
+	if (!name || !slug) return apiError("VALIDATION_ERROR", "Taxonomy name and slug required", 400);
 
 	const dbErr = requireDb(emdash?.db);
 	if (dbErr) return dbErr;
@@ -86,8 +83,11 @@ export const DELETE: APIRoute = async ({ params, locals }) => {
 	const denied = requirePerm(user, "taxonomies:manage");
 	if (denied) return denied;
 
+	const query = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(query)) return query;
+
 	try {
-		const result = await handleTermDelete(emdash.db, name, slug);
+		const result = await handleTermDelete(emdash.db, name, slug, { locale: query.locale });
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to delete term", "TERM_DELETE_ERROR");

package/src/astro/routes/api/taxonomies/[name]/terms/index.ts

@@ -1,8 +1,8 @@
 /**
  * Taxonomy terms list and create endpoint
  *
- * GET /_emdash/api/taxonomies/:name/terms - List all terms (tree for hierarchical)
- * POST /_emdash/api/taxonomies/:name/terms - Create a new term
+ * GET  /_emdash/api/taxonomies/:name/terms[?locale=xx] - List terms (tree for hierarchical)
+ * POST /_emdash/api/taxonomies/:name/terms              - Create a new term (body may include locale & translationOf)
  */
 
 import type { APIRoute } from "astro";
@@ -10,21 +10,18 @@ import type { APIRoute } from "astro";
 import { requirePerm } from "#api/authorize.js";
 import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
 import { handleTermCreate, handleTermList } from "#api/handlers/taxonomies.js";
-import { isParseError, parseBody } from "#api/parse.js";
-import { createTermBody } from "#api/schemas.js";
+import { isParseError, parseBody, parseQuery } from "#api/parse.js";
+import { createTermBody, localeFilterQuery } from "#api/schemas.js";
 
 export const prerender = false;
 
 /**
  * List all terms for a taxonomy
  */
-export const GET: APIRoute = async ({ params, locals }) => {
+export const GET: APIRoute = async ({ params, request, locals }) => {
 	const { emdash, user } = locals;
 	const { name } = params;
-
-	if (!name) {
-		return apiError("VALIDATION_ERROR", "Taxonomy name required", 400);
-	}
+	if (!name) return apiError("VALIDATION_ERROR", "Taxonomy name required", 400);
 
 	const dbErr = requireDb(emdash?.db);
 	if (dbErr) return dbErr;
@@ -32,8 +29,11 @@ export const GET: APIRoute = async ({ params, locals }) => {
 	const denied = requirePerm(user, "taxonomies:read");
 	if (denied) return denied;
 
+	const query = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(query)) return query;
+
 	try {
-		const result = await handleTermList(emdash.db, name);
+		const result = await handleTermList(emdash.db, name, { locale: query.locale });
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to list terms", "TERM_LIST_ERROR");
@@ -46,10 +46,7 @@ export const GET: APIRoute = async ({ params, locals }) => {
 export const POST: APIRoute = async ({ params, request, locals }) => {
 	const { emdash, user } = locals;
 	const { name } = params;
-
-	if (!name) {
-		return apiError("VALIDATION_ERROR", "Taxonomy name required", 400);
-	}
+	if (!name) return apiError("VALIDATION_ERROR", "Taxonomy name required", 400);
 
 	const dbErr = requireDb(emdash?.db);
 	if (dbErr) return dbErr;

package/src/astro/routes/api/taxonomies/index.ts

@@ -1,8 +1,8 @@
 /**
  * Taxonomy definitions endpoint
  *
- * GET  /_emdash/api/taxonomies - List all taxonomy definitions
- * POST /_emdash/api/taxonomies - Create a custom taxonomy definition
+ * GET  /_emdash/api/taxonomies[?locale=xx] - List taxonomy definitions
+ * POST /_emdash/api/taxonomies              - Create a custom taxonomy definition
  */
 
 import type { APIRoute } from "astro";
@@ -10,15 +10,15 @@ import type { APIRoute } from "astro";
 import { requirePerm } from "#api/authorize.js";
 import { handleError, requireDb, unwrapResult } from "#api/error.js";
 import { handleTaxonomyCreate, handleTaxonomyList } from "#api/handlers/taxonomies.js";
-import { isParseError, parseBody } from "#api/parse.js";
-import { createTaxonomyDefBody } from "#api/schemas.js";
+import { isParseError, parseBody, parseQuery } from "#api/parse.js";
+import { createTaxonomyDefBody, localeFilterQuery } from "#api/schemas.js";
 
 export const prerender = false;
 
 /**
  * List taxonomy definitions
  */
-export const GET: APIRoute = async ({ locals }) => {
+export const GET: APIRoute = async ({ request, locals }) => {
 	const { emdash, user } = locals;
 
 	const dbErr = requireDb(emdash?.db);
@@ -27,8 +27,11 @@ export const GET: APIRoute = async ({ locals }) => {
 	const denied = requirePerm(user, "taxonomies:read");
 	if (denied) return denied;
 
+	const query = parseQuery(new URL(request.url), localeFilterQuery);
+	if (isParseError(query)) return query;
+
 	try {
-		const result = await handleTaxonomyList(emdash.db);
+		const result = await handleTaxonomyList(emdash.db, { locale: query.locale });
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to list taxonomies", "TAXONOMY_LIST_ERROR");

package/src/cli/commands/export-seed.ts

@@ -212,41 +212,69 @@ async function exportCollections(db: Kysely<Database>): Promise<SeedCollection[]
  * Export taxonomy definitions and terms
  */
 async function exportTaxonomies(db: Kysely<Database>): Promise<SeedTaxonomy[]> {
-	// Get taxonomy definitions
-	const defs = await db.selectFrom("_emdash_taxonomy_defs").selectAll().execute();
+	const i18nEnabled = isI18nEnabled();
+
+	// Mirrors the content export pattern: one entry per (name, locale), stable
+	// seed-local id, translations linked via `translationOf` to the anchor's id.
+	const defs = await db
+		.selectFrom("_emdash_taxonomy_defs")
+		.selectAll()
+		.orderBy(["name", "locale"])
+		.execute();
 
 	const result: SeedTaxonomy[] = [];
 	const termRepo = new TaxonomyRepository(db);
 
+	// translation_group -> seed-local id of first def we emitted in that group.
+	const defGroupToSeedId = new Map<string, string>();
+
 	for (const def of defs) {
-		// Get terms for this taxonomy
-		const terms = await termRepo.findByName(def.name);
+		const defSeedId =
+			i18nEnabled && def.locale ? `tax:${def.name}:${def.locale}` : `tax:${def.name}`;
 
-		// Build term tree for hierarchical taxonomies
-		const seedTerms: SeedTaxonomyTerm[] = [];
+		// Terms in this def's locale.
+		const terms = await termRepo.findByName(def.name, { locale: def.locale });
 
-		// First, create a map of id -> slug for parent resolution
+		// id -> slug for parent resolution within this locale.
 		const idToSlug = new Map<string, string>();
-		for (const term of terms) {
-			idToSlug.set(term.id, term.slug);
-		}
+		for (const term of terms) idToSlug.set(term.id, term.slug);
+
+		// translation_group -> seed id of the anchor term.
+		const termGroupToSeedId = new Map<string, string>();
 
+		const seedTerms: SeedTaxonomyTerm[] = [];
 		for (const term of terms) {
+			const termSeedId =
+				i18nEnabled && term.locale
+					? `term:${def.name}:${term.slug}:${term.locale}`
+					: `term:${def.name}:${term.slug}`;
+
 			const seedTerm: SeedTaxonomyTerm = {
+				id: termSeedId,
 				slug: term.slug,
 				label: term.label,
 				description: typeof term.data?.description === "string" ? term.data.description : undefined,
 			};
 
-			// Resolve parent slug
-			if (term.parentId) {
-				seedTerm.parent = idToSlug.get(term.parentId);
+			if (term.parentId) seedTerm.parent = idToSlug.get(term.parentId);
+
+			if (i18nEnabled && term.locale) {
+				seedTerm.locale = term.locale;
+				if (term.translationGroup) {
+					const anchor = termGroupToSeedId.get(term.translationGroup);
+					if (anchor) seedTerm.translationOf = anchor;
+					else termGroupToSeedId.set(term.translationGroup, termSeedId);
+				}
 			}
 
 			seedTerms.push(seedTerm);
 		}
 
+		// Anchors first so import can resolve `translationOf`.
+		seedTerms.sort((a, b) => Number(!!a.translationOf) - Number(!!b.translationOf));
+
 		const taxonomy: SeedTaxonomy = {
+			id: defSeedId,
 			name: def.name,
 			label: def.label,
 			labelSingular: def.label_singular || undefined,
@@ -254,13 +282,23 @@ async function exportTaxonomies(db: Kysely<Database>): Promise<SeedTaxonomy[]> {
 			collections: def.collections ? JSON.parse(def.collections) : [],
 		};
 
-		if (seedTerms.length > 0) {
-			taxonomy.terms = seedTerms;
+		if (i18nEnabled && def.locale) {
+			taxonomy.locale = def.locale;
+			if (def.translation_group) {
+				const anchor = defGroupToSeedId.get(def.translation_group);
+				if (anchor) taxonomy.translationOf = anchor;
+				else defGroupToSeedId.set(def.translation_group, defSeedId);
+			}
 		}
 
+		if (seedTerms.length > 0) taxonomy.terms = seedTerms;
+
 		result.push(taxonomy);
 	}
 
+	// Anchors first at def level too.
+	result.sort((a, b) => Number(!!a.translationOf) - Number(!!b.translationOf));
+
 	return result;
 }
 
@@ -268,13 +306,22 @@ async function exportTaxonomies(db: Kysely<Database>): Promise<SeedTaxonomy[]> {
  * Export menus with their items
  */
 async function exportMenus(db: Kysely<Database>): Promise<SeedMenu[]> {
-	// Get all menus
-	const menus = await db.selectFrom("_emdash_menus").selectAll().execute();
+	const i18nEnabled = isI18nEnabled();
+
+	const menus = await db
+		.selectFrom("_emdash_menus")
+		.selectAll()
+		.orderBy(["name", "locale"])
+		.execute();
 
 	const result: SeedMenu[] = [];
+	// translation_group -> seed-local id of the anchor menu in that group.
+	const groupToSeedId = new Map<string, string>();
 
 	for (const menu of menus) {
-		// Get menu items
+		const seedId =
+			i18nEnabled && menu.locale ? `menu:${menu.name}:${menu.locale}` : `menu:${menu.name}`;
+
 		const items = await db
 			.selectFrom("_emdash_menu_items")
 			.selectAll()
@@ -282,16 +329,30 @@ async function exportMenus(db: Kysely<Database>): Promise<SeedMenu[]> {
 			.orderBy("sort_order", "asc")
 			.execute();
 
-		// Build item tree
 		const seedItems = buildMenuItemTree(items);
 
-		result.push({
+		const seedMenu: SeedMenu = {
+			id: seedId,
 			name: menu.name,
 			label: menu.label,
 			items: seedItems,
-		});
+		};
+
+		if (i18nEnabled && menu.locale) {
+			seedMenu.locale = menu.locale;
+			if (menu.translation_group) {
+				const anchor = groupToSeedId.get(menu.translation_group);
+				if (anchor) seedMenu.translationOf = anchor;
+				else groupToSeedId.set(menu.translation_group, seedId);
+			}
+		}
+
+		result.push(seedMenu);
 	}
 
+	// Anchors first so import can resolve `translationOf`.
+	result.sort((a, b) => Number(!!a.translationOf) - Number(!!b.translationOf));
+
 	return result;
 }