emdash 0.8.0 → 0.10.0

package/src/redirects/cache.ts

@@ -1,8 +1,13 @@
 /**
- * Redirect pattern cache.
+ * Redirect rule cache.
  *
- * Module-level cache for compiled redirect pattern rules. The middleware
- * populates this on first request; route handlers invalidate it on writes.
+ * Module-level cache for enabled redirect rules. The middleware populates this
+ * on first request; route handlers invalidate it on writes.
+ *
+ * Both exact-match and pattern rules are loaded from one query and cached
+ * together: exact rules indexed by source path in a Map, pattern rules
+ * pre-compiled into an array. A single warm request issues zero database
+ * queries; a cold isolate issues one.
  *
  * This module deliberately has NO Astro imports so it can be safely imported
  * from handlers, seed, CLI, and tests without dragging in `astro:middleware`.
@@ -17,36 +22,51 @@ export interface CachedRedirectRule {
 	compiled: CompiledPattern;
 }
 
+export interface CachedRedirects {
+	/** Exact-match rules indexed by source path (`source` -> `Redirect`). */
+	exact: Map<string, Redirect>;
+	/** Pattern rules with their compiled regexes, preserving insertion order. */
+	patterns: CachedRedirectRule[];
+}
+
 /**
- * Cached pattern rules with compiled regexes.
- * null = not yet populated, array = cached.
+ * Cached enabled redirects.
+ * null = not yet populated, object = cached.
  */
-let cachedPatternRules: CachedRedirectRule[] | null = null;
+let cachedRedirects: CachedRedirects | null = null;
 
 /**
- * Invalidate the cached redirect pattern rules.
+ * Invalidate the cached redirects (both exact and pattern).
  * Call when redirects are created, updated, or deleted.
  */
 export function invalidateRedirectCache(): void {
-	cachedPatternRules = null;
+	cachedRedirects = null;
 }
 
 /**
- * Get the cached compiled pattern rules, or null if the cache is cold.
+ * Get the cached redirects, or null if the cache is cold.
  */
-export function getCachedPatternRules(): CachedRedirectRule[] | null {
-	return cachedPatternRules;
+export function getCachedRedirects(): CachedRedirects | null {
+	return cachedRedirects;
 }
 
 /**
- * Populate the pattern rules cache from a list of enabled pattern redirects.
+ * Populate the cache from a list of enabled redirects (both exact and
+ * pattern). The caller is responsible for passing only enabled rows — the
+ * cache stores them as-is.
  */
-export function setCachedPatternRules(redirects: Redirect[]): CachedRedirectRule[] {
-	cachedPatternRules = redirects.map((r) => ({
-		redirect: r,
-		compiled: compilePattern(r.source),
-	}));
-	return cachedPatternRules;
+export function setCachedRedirects(redirects: Redirect[]): CachedRedirects {
+	const exact = new Map<string, Redirect>();
+	const patterns: CachedRedirectRule[] = [];
+	for (const r of redirects) {
+		if (r.isPattern) {
+			patterns.push({ redirect: r, compiled: compilePattern(r.source) });
+		} else {
+			exact.set(r.source, r);
+		}
+	}
+	cachedRedirects = { exact, patterns };
+	return cachedRedirects;
 }
 
 /**

package/src/schema/registry.ts

@@ -8,6 +8,7 @@ import { withTransaction } from "../database/transaction.js";
 import type { CollectionTable, Database, FieldTable } from "../database/types.js";
 import { validateIdentifier } from "../database/validate.js";
 import { FTSManager } from "../search/fts-manager.js";
+import { chunks, SQL_BATCH_SIZE } from "../utils/chunks.js";
 import {
 	type Collection,
 	type CollectionSource,
@@ -143,6 +144,61 @@ export class SchemaRegistry {
 		return { ...collection, fields };
 	}
 
+	/**
+	 * List every collection together with its fields in O(1) query shapes
+	 * — one for collections, then one batched query for the fields of every
+	 * returned collection — instead of the N+1 pattern of `listCollections`
+	 * + per-collection `listFields`. The fields query is chunked at
+	 * `SQL_BATCH_SIZE` to stay under D1's bound-parameter limit, so on
+	 * sites with more than `SQL_BATCH_SIZE` collections the field fetch
+	 * becomes `ceil(collectionCount / SQL_BATCH_SIZE)` queries — still
+	 * a constant factor, not N+1. Typical sites have well under
+	 * `SQL_BATCH_SIZE` collections, so this is two queries in practice.
+	 *
+	 * Used by the manifest build, which previously paid N+1 round-trips on
+	 * every admin request. Each round-trip costs ~80–150ms against the D1
+	 * primary on a busy link, so a 10-collection site spent ~1 s rebuilding
+	 * a manifest that is now built fresh per admin request (no cache).
+	 */
+	async listCollectionsWithFields(): Promise<CollectionWithFields[]> {
+		const collectionRows = await this.db
+			.selectFrom("_emdash_collections")
+			.selectAll()
+			.orderBy("slug", "asc")
+			.execute();
+
+		if (collectionRows.length === 0) return [];
+
+		const fieldsByCollection = new Map<string, Field[]>();
+		// Chunk to stay under D1's bound-parameter limit. Typical sites have
+		// well under SQL_BATCH_SIZE collections, so this is a single query
+		// in practice; on larger sites it becomes a small constant number
+		// of queries, never N+1.
+		for (const idChunk of chunks(
+			collectionRows.map((c) => c.id),
+			SQL_BATCH_SIZE,
+		)) {
+			const fieldRows = await this.db
+				.selectFrom("_emdash_fields")
+				.where("collection_id", "in", idChunk)
+				.selectAll()
+				.orderBy("collection_id", "asc")
+				.orderBy("sort_order", "asc")
+				.orderBy("created_at", "asc")
+				.execute();
+			for (const row of fieldRows) {
+				const list = fieldsByCollection.get(row.collection_id) ?? [];
+				list.push(this.mapFieldRow(row));
+				fieldsByCollection.set(row.collection_id, list);
+			}
+		}
+
+		return collectionRows.map((c) => ({
+			...this.mapCollectionRow(c),
+			fields: fieldsByCollection.get(c.id) ?? [],
+		}));
+	}
+
 	/**
 	 * Create a new collection
 	 */

package/src/schema/zod-generator.ts

@@ -35,9 +35,16 @@ export function generateFieldSchema(field: Field): ZodTypeAny {
 		schema = applyValidation(schema, field);
 	}
 
-	// Apply required/optional
+	// Apply required/optional. Non-required fields use `.nullish()` rather
+	// than `.optional()` because the underlying SQLite columns are nullable
+	// (see `SchemaRegistry.addFieldColumn` -- non-required fields are added
+	// without `NOT NULL`). The admin re-sends what it loaded from the
+	// server on autosave, so any field that's actually `null` in the DB
+	// must round-trip cleanly through the validator. `.optional()` only
+	// accepts `undefined`; `.nullish()` accepts both `undefined` and
+	// `null`. (#867 — autosave failures on seeded entries.)
 	if (!field.required) {
-		schema = schema.optional();
+		schema = schema.nullish();
 	}
 
 	// Apply default value
@@ -68,7 +75,15 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 			return z.number().int();
 
 		case "boolean":
-			return z.boolean();
+			// Boolean fields map to `INTEGER` columns (`FIELD_TYPE_TO_COLUMN`
+			// in `schema/types.ts`) and `serializeValue` in
+			// `database/repositories/content.ts` writes booleans as 0/1.
+			// `deserializeValue` never converts them back, so reads return
+			// numbers. Coerce the stored 0/1 shape here so a GET → POST
+			// round-trip on a boolean field passes validation. Other inputs
+			// (strings, other numbers) fall through to `z.boolean()` and
+			// produce its standard rejection.
+			return z.preprocess((v) => (v === 0 || v === 1 ? Boolean(v) : v), z.boolean());
 
 		case "datetime":
 			return z.string().datetime().or(z.string().date());
@@ -92,12 +107,19 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 		}
 
 		case "portableText":
-			// Portable Text is an array of blocks
+			// Portable Text is an array of blocks. We require `_type` because
+			// renderers dispatch on it, but `_key` is intentionally optional:
+			// it's a UI-layer concern that the editor regenerates on every
+			// change (see `PortableTextEditor`), and the rest of this schema
+			// uses `.passthrough()` for everything below the top level. Making
+			// `_key` strictly required here was an accidentally tight invariant
+			// that rejected any seed/import data not authored against the
+			// editor (#867 — autosave failures on seeded template content).
 			return z.array(
 				z
 					.object({
 						_type: z.string(),
-						_key: z.string(),
+						_key: z.string().optional(),
 					})
 					.passthrough(),
 			);
@@ -109,6 +131,12 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 				alt: z.string().optional(),
 				width: z.number().optional(),
 				height: z.number().optional(),
+				/** Provider ID (e.g. "local", "cloudflare-images") */
+				provider: z.string().optional(),
+				/** Admin-side preview URL for external providers (not persisted by plugins) */
+				previewUrl: z.string().optional(),
+				/** Provider-specific metadata; for local media this carries storageKey */
+				meta: z.record(z.string(), z.unknown()).optional(),
 			});
 
 		case "file":
@@ -118,6 +146,10 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 				filename: z.string().optional(),
 				mimeType: z.string().optional(),
 				size: z.number().optional(),
+				/** Provider ID (e.g. "local", "s3") */
+				provider: z.string().optional(),
+				/** Provider-specific metadata; for local media this carries storageKey */
+				meta: z.record(z.string(), z.unknown()).optional(),
 			});
 
 		case "reference":
@@ -362,10 +394,10 @@ function fieldTypeToTypeScript(field: Field): string {
 			return "PortableTextBlock[]";
 
 		case "image":
-			return "{ id: string; src?: string; alt?: string; width?: number; height?: number }";
+			return "{ id: string; src?: string; alt?: string; width?: number; height?: number; provider?: string; previewUrl?: string; meta?: Record<string, unknown> }";
 
 		case "file":
-			return "{ id: string; src?: string; filename?: string; mimeType?: string; size?: number }";
+			return "{ id: string; src?: string; filename?: string; mimeType?: string; size?: number; provider?: string; meta?: Record<string, unknown> }";
 
 		case "reference":
 			// Could be enhanced to include the referenced collection type

package/src/seed/apply.ts

@@ -19,6 +19,7 @@ import { TaxonomyRepository } from "../database/repositories/taxonomy.js";
 import { withTransaction } from "../database/transaction.js";
 import type { Database } from "../database/types.js";
 import type { MediaValue } from "../fields/types.js";
+import { getI18nConfig } from "../i18n/config.js";
 import { ssrfSafeFetch, validateExternalUrl } from "../import/ssrf.js";
 import { SchemaRegistry } from "../schema/registry.js";
 import { FTSManager } from "../search/fts-manager.js";
@@ -219,17 +220,30 @@ export async function applySeed(
 
 	// 4-5. Taxonomies
 	if (seed.taxonomies) {
+		// seed-local id -> resolved info, used to wire `translationOf` refs.
+		const defSeedIdMap = new Map<string, { id: string; translationGroup: string }>();
+		const termSeedIdMap = new Map<string, string>();
+		const fallbackLocale = getI18nConfig()?.defaultLocale ?? "en";
+
 		for (const taxonomy of seed.taxonomies) {
-			// Check if taxonomy definition exists
+			const defLocale = taxonomy.locale ?? fallbackLocale;
+
+			// (name, locale) is the UNIQUE key after migration 036.
 			const existingDef = await db
 				.selectFrom("_emdash_taxonomy_defs")
 				.selectAll()
 				.where("name", "=", taxonomy.name)
+				.where("locale", "=", defLocale)
 				.executeTakeFirst();
 
+			let defId: string;
+			let defTranslationGroup: string;
+
 			if (existingDef) {
+				defId = existingDef.id;
+				defTranslationGroup = existingDef.translation_group ?? existingDef.id;
 				if (onConflict === "error") {
-					throw new Error(`Conflict: taxonomy "${taxonomy.name}" already exists`);
+					throw new Error(`Conflict: taxonomy "${taxonomy.name}" (${defLocale}) already exists`);
 				}
 				if (onConflict === "update") {
 					await db
@@ -242,40 +256,59 @@ export async function applySeed(
 						})
 						.where("id", "=", existingDef.id)
 						.execute();
-					// Taxonomy defs don't track an "updated" counter -- just the definition is updated
 				}
-				// skip: do nothing for the definition
 			} else {
-				// Create taxonomy definition
+				defId = ulid();
+				defTranslationGroup = defId;
+				if (taxonomy.translationOf) {
+					const source = defSeedIdMap.get(taxonomy.translationOf);
+					if (source) defTranslationGroup = source.translationGroup;
+					else
+						console.warn(
+							`taxonomy "${taxonomy.name}" (${defLocale}): translationOf "${taxonomy.translationOf}" not found yet; minting a fresh group.`,
+						);
+				}
 				await db
 					.insertInto("_emdash_taxonomy_defs")
 					.values({
-						id: ulid(),
+						id: defId,
 						name: taxonomy.name,
 						label: taxonomy.label,
 						label_singular: taxonomy.labelSingular ?? null,
 						hierarchical: taxonomy.hierarchical ? 1 : 0,
 						collections: JSON.stringify(taxonomy.collections),
+						locale: defLocale,
+						translation_group: defTranslationGroup,
 					})
 					.execute();
 				result.taxonomies.created++;
 			}
 
+			if (taxonomy.id)
+				defSeedIdMap.set(taxonomy.id, { id: defId, translationGroup: defTranslationGroup });
+
 			// Create terms (if provided)
 			if (taxonomy.terms && taxonomy.terms.length > 0) {
 				const termRepo = new TaxonomyRepository(db);
 
-				// For hierarchical taxonomies, we need to create parents before children
 				if (taxonomy.hierarchical) {
-					await applyHierarchicalTerms(termRepo, taxonomy.name, taxonomy.terms, result, onConflict);
+					await applyHierarchicalTerms(
+						termRepo,
+						taxonomy.name,
+						defLocale,
+						taxonomy.terms,
+						termSeedIdMap,
+						result,
+						onConflict,
+					);
 				} else {
-					// Flat taxonomy - create all terms
 					for (const term of taxonomy.terms) {
-						const existing = await termRepo.findBySlug(taxonomy.name, term.slug);
+						const termLocale = term.locale ?? defLocale;
+						const existing = await termRepo.findBySlug(taxonomy.name, term.slug, termLocale);
 						if (existing) {
 							if (onConflict === "error") {
 								throw new Error(
-									`Conflict: taxonomy term "${term.slug}" in "${taxonomy.name}" already exists`,
+									`Conflict: taxonomy term "${term.slug}" in "${taxonomy.name}" (${termLocale}) already exists`,
 								);
 							}
 							if (onConflict === "update") {
@@ -285,14 +318,20 @@ export async function applySeed(
 								});
 								result.taxonomies.terms++;
 							}
-							// skip: do nothing
+							if (term.id) termSeedIdMap.set(term.id, existing.id);
 						} else {
-							await termRepo.create({
+							const translationOf = term.translationOf
+								? termSeedIdMap.get(term.translationOf)
+								: undefined;
+							const created = await termRepo.create({
 								name: taxonomy.name,
 								slug: term.slug,
 								label: term.label,
 								data: term.description ? { description: term.description } : undefined,
+								locale: termLocale,
+								translationOf,
 							});
+							if (term.id) termSeedIdMap.set(term.id, created.id);
 							result.taxonomies.terms++;
 						}
 					}
@@ -471,23 +510,39 @@ export async function applySeed(
 
 	// 8. Menus and Menu Items (after content so refs can resolve)
 	if (seed.menus) {
+		// seed-local id -> resolved info, used to wire `translationOf` refs.
+		const menuSeedIdMap = new Map<string, { id: string; translationGroup: string }>();
+		const fallbackLocale = getI18nConfig()?.defaultLocale ?? "en";
+
 		for (const menu of seed.menus) {
-			// Check if menu exists
-			const existingMenu = await db
+			const locale = menu.locale ?? fallbackLocale;
+			let lookup = db
 				.selectFrom("_emdash_menus")
 				.selectAll()
 				.where("name", "=", menu.name)
-				.executeTakeFirst();
+				.where("locale", "=", locale);
+			const existingMenu = await lookup.executeTakeFirst();
 
 			let menuId: string;
+			let translationGroup: string;
 
 			if (existingMenu) {
 				menuId = existingMenu.id;
+				translationGroup = existingMenu.translation_group ?? existingMenu.id;
 				// Clear existing items (menus are recreated)
 				await db.deleteFrom("_emdash_menu_items").where("menu_id", "=", menuId).execute();
 			} else {
-				// Create menu
 				menuId = ulid();
+				// Resolve translationOf to the source menu's translation_group.
+				translationGroup = menuId;
+				if (menu.translationOf) {
+					const source = menuSeedIdMap.get(menu.translationOf);
+					if (source) translationGroup = source.translationGroup;
+					else
+						console.warn(
+							`menu "${menu.name}" (${locale}): translationOf "${menu.translationOf}" not found yet; minting a fresh group.`,
+						);
+				}
 				await db
 					.insertInto("_emdash_menus")
 					.values({
@@ -496,15 +551,20 @@ export async function applySeed(
 						label: menu.label,
 						created_at: new Date().toISOString(),
 						updated_at: new Date().toISOString(),
+						locale,
+						translation_group: translationGroup,
 					})
 					.execute();
 				result.menus.created++;
 			}
 
+			if (menu.id) menuSeedIdMap.set(menu.id, { id: menuId, translationGroup });
+
 			// Create menu items
 			const itemCount = await applyMenuItems(
 				db,
 				menuId,
+				locale,
 				menu.items,
 				null, // parent_id
 				0, // sort_order
@@ -692,64 +752,75 @@ export async function applySeed(
 async function applyHierarchicalTerms(
 	termRepo: TaxonomyRepository,
 	taxonomyName: string,
+	defLocale: string,
 	terms: SeedTaxonomyTerm[],
+	termSeedIdMap: Map<string, string>,
 	result: SeedApplyResult,
 	onConflict: "skip" | "update" | "error" = "skip",
 ): Promise<void> {
-	// Map slugs to IDs
+	// "locale::slug" -> id, so the same slug can resolve per locale.
 	const slugToId = new Map<string, string>();
 
-	// Multiple passes to handle deep nesting
+	// Multiple passes — handles deep nesting and translationOf forward refs.
 	let remaining = [...terms];
-	let maxPasses = 10; // Prevent infinite loop
+	let maxPasses = 10;
 
 	while (remaining.length > 0 && maxPasses > 0) {
 		const processedThisPass: string[] = [];
 
 		for (const term of remaining) {
-			// Check if parent exists (or no parent)
-			if (!term.parent || slugToId.has(term.parent)) {
-				const parentId = term.parent ? slugToId.get(term.parent) : undefined;
+			const termLocale = term.locale ?? defLocale;
+			const parentReady = !term.parent || slugToId.has(`${termLocale}::${term.parent}`);
+			const translationReady = !term.translationOf || termSeedIdMap.has(term.translationOf);
 
-				const existing = await termRepo.findBySlug(taxonomyName, term.slug);
-				if (existing) {
-					if (onConflict === "error") {
-						throw new Error(
-							`Conflict: taxonomy term "${term.slug}" in "${taxonomyName}" already exists`,
-						);
-					}
-					if (onConflict === "update") {
-						await termRepo.update(existing.id, {
-							label: term.label,
-							parentId,
-							data: term.description ? { description: term.description } : {},
-						});
-						result.taxonomies.terms++;
-					}
-					slugToId.set(term.slug, existing.id);
-				} else {
-					const created = await termRepo.create({
-						name: taxonomyName,
-						slug: term.slug,
+			if (!parentReady || !translationReady) continue;
+
+			const parentId = term.parent ? slugToId.get(`${termLocale}::${term.parent}`) : undefined;
+			const translationOf = term.translationOf ? termSeedIdMap.get(term.translationOf) : undefined;
+
+			const existing = await termRepo.findBySlug(taxonomyName, term.slug, termLocale);
+			if (existing) {
+				if (onConflict === "error") {
+					throw new Error(
+						`Conflict: taxonomy term "${term.slug}" in "${taxonomyName}" (${termLocale}) already exists`,
+					);
+				}
+				if (onConflict === "update") {
+					await termRepo.update(existing.id, {
 						label: term.label,
 						parentId,
-						data: term.description ? { description: term.description } : undefined,
+						data: term.description ? { description: term.description } : {},
 					});
-					slugToId.set(term.slug, created.id);
 					result.taxonomies.terms++;
 				}
-
-				processedThisPass.push(term.slug);
+				slugToId.set(`${termLocale}::${term.slug}`, existing.id);
+				if (term.id) termSeedIdMap.set(term.id, existing.id);
+			} else {
+				const created = await termRepo.create({
+					name: taxonomyName,
+					slug: term.slug,
+					label: term.label,
+					parentId,
+					data: term.description ? { description: term.description } : undefined,
+					locale: termLocale,
+					translationOf,
+				});
+				slugToId.set(`${termLocale}::${term.slug}`, created.id);
+				if (term.id) termSeedIdMap.set(term.id, created.id);
+				result.taxonomies.terms++;
 			}
+
+			processedThisPass.push(term.slug + "::" + termLocale);
 		}
 
-		// Remove processed terms
-		remaining = remaining.filter((t) => !processedThisPass.includes(t.slug));
+		remaining = remaining.filter(
+			(t) => !processedThisPass.includes(t.slug + "::" + (t.locale ?? defLocale)),
+		);
 		maxPasses--;
 	}
 
 	if (remaining.length > 0) {
-		console.warn(`Could not process ${remaining.length} terms due to missing parents`);
+		console.warn(`Could not process ${remaining.length} terms due to missing parents/translations`);
 	}
 }
 
@@ -847,11 +918,18 @@ async function applyContentTaxonomies(
 }
 
 /**
- * Apply menu items recursively
+ * Apply menu items recursively.
+ *
+ * Each item gets a fresh `translation_group` (= its own id). The seed format's
+ * `SeedMenuItem` has no `id`/`translationOf` fields, so we can't express the
+ * cross-locale "same nav entry" link here — items diverge across locales on
+ * re-apply. Runtime navigation still resolves correctly because `reference_id`
+ * already holds the content's translation_group.
  */
 async function applyMenuItems(
 	db: Kysely<Database>,
 	menuId: string,
+	locale: string,
 	items: SeedMenuItem[],
 	parentId: string | null,
 	startOrder: number,
@@ -877,7 +955,6 @@ async function applyMenuItems(
 			// If not in map, the content might not exist yet (will be broken link)
 		}
 
-		// Insert menu item
 		await db
 			.insertInto("_emdash_menu_items")
 			.values({
@@ -894,15 +971,24 @@ async function applyMenuItems(
 				target: item.target ?? null,
 				css_classes: item.cssClasses ?? null,
 				created_at: new Date().toISOString(),
+				locale,
+				translation_group: itemId,
 			})
 			.execute();
 
 		count++;
 		order++;
 
-		// Process children
 		if (item.children && item.children.length > 0) {
-			const childCount = await applyMenuItems(db, menuId, item.children, itemId, 0, seedIdMap);
+			const childCount = await applyMenuItems(
+				db,
+				menuId,
+				locale,
+				item.children,
+				itemId,
+				0,
+				seedIdMap,
+			);
 			count += childCount;
 		}
 	}
@@ -927,6 +1013,8 @@ async function applyWidget(
 			sort_order: sortOrder,
 			type: widget.type,
 			title: widget.title ?? null,
+			// `widget.content` is Portable Text for content-type widgets;
+			// for other widget kinds it's null.
 			content: widget.content ? JSON.stringify(widget.content) : null,
 			menu_name: widget.menuName ?? null,
 			component_id: widget.componentId ?? null,

package/src/seed/types.ts

@@ -87,14 +87,19 @@ export interface SeedField {
 }
 
 /**
- * Taxonomy definition in seed
+ * Taxonomy definition in seed. For multi-locale exports each locale variant
+ * is its own entry, linked via `translationOf` (referencing another entry's `id`).
  */
 export interface SeedTaxonomy {
+	/** Optional seed-local id, e.g. "tax:category:en". Target of `translationOf`. */
+	id?: string;
 	name: string;
 	label: string;
 	labelSingular?: string;
 	hierarchical: boolean;
 	collections: string[];
+	locale?: string;
+	translationOf?: string;
 	terms?: SeedTaxonomyTerm[];
 }
 
@@ -102,18 +107,26 @@ export interface SeedTaxonomy {
  * Taxonomy term in seed
  */
 export interface SeedTaxonomyTerm {
+	/** Optional seed-local id, e.g. "term:category:news:en". */
+	id?: string;
 	slug: string;
 	label: string;
 	description?: string;
 	parent?: string; // Slug of parent term (for hierarchical taxonomies)
+	locale?: string;
+	translationOf?: string;
 }
 
 /**
  * Menu definition in seed
  */
 export interface SeedMenu {
+	/** Optional seed-local id, e.g. "menu:primary:en". */
+	id?: string;
 	name: string;
 	label: string;
+	locale?: string;
+	translationOf?: string;
 	items: SeedMenuItem[];
 }