emdash 0.9.0 → 0.11.0

package/dist/{adapters-DoNJiveC.d.mts → adapters-BktHA7EO.d.mts}

@@ -118,4 +118,4 @@ interface PostgresConfig {
 declare function postgres(config: PostgresConfig): DatabaseDescriptor;
 //#endregion
 export { SqliteConfig as a, sqlite as c, PostgresConfig as i, DatabaseDialectType as n, libsql as o, LibsqlConfig as r, postgres as s, DatabaseDescriptor as t };
-//# sourceMappingURL=adapters-DoNJiveC.d.mts.map
+//# sourceMappingURL=adapters-BktHA7EO.d.mts.map

package/dist/{adapters-DoNJiveC.d.mts.map → adapters-BktHA7EO.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"adapters-DoNJiveC.d.mts","names":[],"sources":["../src/db/adapters.ts"],"mappings":";;AA0BA;;;;;AAKA;;;;;;;;;;;AAqBA;;;;;AAOA;;;KAjCY,mBAAA;;AAsDZ;;UAjDiB,kBAAA;EAChB,UAAA;EACA,MAAA;EACA,IAAA,EAAM,mBAAA;EA8CuC;;;AAqB9C;;;;;;;;;AAWA;;EA/DC,oBAAA;AAAA;AAAA,UAGgB,YAAA;EA8DhB;;;EA1DA,GAAA;AAAA;AAAA,UAGgB,YAAA;EA6DhB;;;EAzDA,GAAA;EAyD0B;AAa3B;;EAlEC,SAAA;AAAA;;;;;;;;;;;iBAae,MAAA,CAAO,MAAA,EAAQ,YAAA,GAAe,kBAAA;;;;;;;;;;;;;;iBAqB9B,MAAA,CAAO,MAAA,EAAQ,YAAA,GAAe,kBAAA;;;;UAW7B,cAAA;EAChB,gBAAA;EACA,IAAA;EACA,IAAA;EACA,QAAA;EACA,IAAA;EACA,QAAA;EACA,GAAA;EACA,IAAA;IAAS,GAAA;IAAc,GAAA;EAAA;AAAA;;;;;;;;;;;iBAaR,QAAA,CAAS,MAAA,EAAQ,cAAA,GAAiB,kBAAA"}
+{"version":3,"file":"adapters-BktHA7EO.d.mts","names":[],"sources":["../src/db/adapters.ts"],"mappings":";;AA0BA;;;;;AAKA;;;;;;;;;;;AAqBA;;;;;AAOA;;;KAjCY,mBAAA;;AAsDZ;;UAjDiB,kBAAA;EAChB,UAAA;EACA,MAAA;EACA,IAAA,EAAM,mBAAA;EA8CuC;;;AAqB9C;;;;;;;;;AAWA;;EA/DC,oBAAA;AAAA;AAAA,UAGgB,YAAA;EA8DhB;;;EA1DA,GAAA;AAAA;AAAA,UAGgB,YAAA;EA6DhB;;;EAzDA,GAAA;EAyD0B;AAa3B;;EAlEC,SAAA;AAAA;;;;;;;;;;;iBAae,MAAA,CAAO,MAAA,EAAQ,YAAA,GAAe,kBAAA;;;;;;;;;;;;;;iBAqB9B,MAAA,CAAO,MAAA,EAAQ,YAAA,GAAe,kBAAA;;;;UAW7B,cAAA;EAChB,gBAAA;EACA,IAAA;EACA,IAAA;EACA,QAAA;EACA,IAAA;EACA,QAAA;EACA,GAAA;EACA,IAAA;IAAS,GAAA;IAAc,GAAA;EAAA;AAAA;;;;;;;;;;;iBAaR,QAAA,CAAS,MAAA,EAAQ,cAAA,GAAiB,kBAAA"}

package/dist/{apply-BzltprvY.mjs → apply-Ded_1vng.mjs}

@@ -1,183 +1,20 @@
-import { i as __exportAll } from "./runner-C7ADox5q.mjs";
-import { r as RevisionRepository, t as ContentRepository } from "./content-8lOYF0pr.mjs";
-import { t as MediaRepository } from "./media-BW32b4gi.mjs";
-import { t as OptionsRepository } from "./options-BVp3UsTS.mjs";
-import { t as withTransaction } from "./transaction-Cn2rjY78.mjs";
-import { t as RedirectRepository } from "./redirect-BhUBKRc1.mjs";
-import { t as BylineRepository } from "./byline-BSaNL1w7.mjs";
-import { i as FTSManager, n as SchemaRegistry } from "./registry-Dw70ChxB.mjs";
-import { r as getDb } from "./loader-CKLbBnhK.mjs";
-import { n as requestCached, t as peekRequestCache } from "./request-cache-B-bmkipQ.mjs";
-import { t as validateSeed } from "./validate-Baqf0slj.mjs";
+import { i as __exportAll } from "./runner-DIcU2UCC.mjs";
+import { n as getI18nConfig } from "./config-CVssduLe.mjs";
+import { r as RevisionRepository, t as ContentRepository } from "./content-CERxPUN0.mjs";
+import { t as MediaRepository } from "./media-1fFhub9c.mjs";
+import { t as TaxonomyRepository } from "./taxonomy-D6NvlKo8.mjs";
+import { t as OptionsRepository } from "./options-nPxWnrya.mjs";
+import { t as withTransaction } from "./transaction-D44LBXvU.mjs";
+import { t as RedirectRepository } from "./redirect-C5H7VGIX.mjs";
+import { t as BylineRepository } from "./byline-gFn1r0vA.mjs";
+import { n as requestCached, t as peekRequestCache } from "./request-cache-D4I69LeL.mjs";
+import { i as FTSManager, n as SchemaRegistry } from "./registry-Do34mz_P.mjs";
+import { r as getDb } from "./loader-ou_PXAjg.mjs";
+import { t as validateSeed } from "./validate-UK4Ja1uo.mjs";
 import { ulid } from "ulidx";
 import { imageSize } from "image-size";
 import mime from "mime/lite";
 
-//#region src/database/repositories/taxonomy.ts
-/**
-* Taxonomy repository for categories, tags, and other classification
-*
-* Taxonomies are hierarchical (via parentId) and can be attached to content entries.
-*/
-var TaxonomyRepository = class {
-	constructor(db) {
-		this.db = db;
-	}
-	/**
-	* Create a new taxonomy term
-	*/
-	async create(input) {
-		const id = ulid();
-		const parentId = input.parentId === void 0 || input.parentId === "" ? null : input.parentId;
-		const row = {
-			id,
-			name: input.name,
-			slug: input.slug,
-			label: input.label,
-			parent_id: parentId,
-			data: input.data ? JSON.stringify(input.data) : null
-		};
-		await this.db.insertInto("taxonomies").values(row).execute();
-		const taxonomy = await this.findById(id);
-		if (!taxonomy) throw new Error("Failed to create taxonomy");
-		return taxonomy;
-	}
-	/**
-	* Find taxonomy by ID
-	*/
-	async findById(id) {
-		const row = await this.db.selectFrom("taxonomies").selectAll().where("id", "=", id).executeTakeFirst();
-		return row ? this.rowToTaxonomy(row) : null;
-	}
-	/**
-	* Find taxonomy by name and slug (unique constraint)
-	*/
-	async findBySlug(name, slug) {
-		const row = await this.db.selectFrom("taxonomies").selectAll().where("name", "=", name).where("slug", "=", slug).executeTakeFirst();
-		return row ? this.rowToTaxonomy(row) : null;
-	}
-	/**
-	* Get all terms for a taxonomy (e.g., all categories)
-	*/
-	async findByName(name, options = {}) {
-		let query = this.db.selectFrom("taxonomies").selectAll().where("name", "=", name).orderBy("label", "asc").orderBy("id", "asc");
-		if (options.parentId !== void 0) if (options.parentId === null) query = query.where("parent_id", "is", null);
-		else query = query.where("parent_id", "=", options.parentId);
-		return (await query.execute()).map((row) => this.rowToTaxonomy(row));
-	}
-	/**
-	* Get children of a taxonomy term
-	*/
-	async findChildren(parentId) {
-		return (await this.db.selectFrom("taxonomies").selectAll().where("parent_id", "=", parentId).orderBy("label", "asc").orderBy("id", "asc").execute()).map((row) => this.rowToTaxonomy(row));
-	}
-	/**
-	* Update a taxonomy term
-	*/
-	async update(id, input) {
-		if (!await this.findById(id)) return null;
-		const updates = {};
-		if (input.slug !== void 0) updates.slug = input.slug;
-		if (input.label !== void 0) updates.label = input.label;
-		if (input.parentId !== void 0) updates.parent_id = input.parentId === "" ? null : input.parentId;
-		if (input.data !== void 0) updates.data = JSON.stringify(input.data);
-		if (Object.keys(updates).length > 0) await this.db.updateTable("taxonomies").set(updates).where("id", "=", id).execute();
-		return this.findById(id);
-	}
-	/**
-	* Delete a taxonomy term
-	*/
-	async delete(id) {
-		await this.db.deleteFrom("content_taxonomies").where("taxonomy_id", "=", id).execute();
-		return ((await this.db.deleteFrom("taxonomies").where("id", "=", id).executeTakeFirst()).numDeletedRows ?? 0) > 0;
-	}
-	/**
-	* Attach a taxonomy term to a content entry
-	*/
-	async attachToEntry(collection, entryId, taxonomyId) {
-		const row = {
-			collection,
-			entry_id: entryId,
-			taxonomy_id: taxonomyId
-		};
-		await this.db.insertInto("content_taxonomies").values(row).onConflict((oc) => oc.doNothing()).execute();
-	}
-	/**
-	* Detach a taxonomy term from a content entry
-	*/
-	async detachFromEntry(collection, entryId, taxonomyId) {
-		await this.db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).where("taxonomy_id", "=", taxonomyId).execute();
-	}
-	/**
-	* Get all taxonomy terms for a content entry
-	*/
-	async getTermsForEntry(collection, entryId, taxonomyName) {
-		let query = this.db.selectFrom("content_taxonomies").innerJoin("taxonomies", "taxonomies.id", "content_taxonomies.taxonomy_id").selectAll("taxonomies").where("content_taxonomies.collection", "=", collection).where("content_taxonomies.entry_id", "=", entryId);
-		if (taxonomyName) query = query.where("taxonomies.name", "=", taxonomyName);
-		return (await query.execute()).map((row) => this.rowToTaxonomy(row));
-	}
-	/**
-	* Set all taxonomy terms for a content entry (replaces existing)
-	* Uses batch operations to avoid N+1 queries.
-	*/
-	async setTermsForEntry(collection, entryId, taxonomyName, taxonomyIds) {
-		const current = await this.getTermsForEntry(collection, entryId, taxonomyName);
-		const currentIds = new Set(current.map((t) => t.id));
-		const newIds = new Set(taxonomyIds);
-		const toRemove = current.filter((t) => !newIds.has(t.id)).map((t) => t.id);
-		if (toRemove.length > 0) await this.db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).where("taxonomy_id", "in", toRemove).execute();
-		const toAdd = taxonomyIds.filter((id) => !currentIds.has(id));
-		if (toAdd.length > 0) await this.db.insertInto("content_taxonomies").values(toAdd.map((taxonomy_id) => ({
-			collection,
-			entry_id: entryId,
-			taxonomy_id
-		}))).onConflict((oc) => oc.doNothing()).execute();
-	}
-	/**
-	* Remove all taxonomy associations for an entry (use when entry is deleted)
-	*/
-	async clearEntryTerms(collection, entryId) {
-		const result = await this.db.deleteFrom("content_taxonomies").where("collection", "=", collection).where("entry_id", "=", entryId).executeTakeFirst();
-		return Number(result.numDeletedRows ?? 0);
-	}
-	/**
-	* Count entries that have a specific taxonomy term
-	*/
-	async countEntriesWithTerm(taxonomyId) {
-		const result = await this.db.selectFrom("content_taxonomies").select((eb) => eb.fn.count("entry_id").as("count")).where("taxonomy_id", "=", taxonomyId).executeTakeFirst();
-		return Number(result?.count || 0);
-	}
-	/**
-	* Batch count entries for multiple taxonomy term IDs.
-	* Chunks the query at SQL_BATCH_SIZE to stay below D1's bind-parameter limit.
-	* Returns a Map from term ID to count.
-	*/
-	async countEntriesForTerms(termIds) {
-		if (termIds.length === 0) return /* @__PURE__ */ new Map();
-		const { chunks, SQL_BATCH_SIZE } = await import("./chunks-NBQVDOci.mjs").then((n) => n.r);
-		const counts = /* @__PURE__ */ new Map();
-		for (const chunk of chunks(termIds, SQL_BATCH_SIZE)) {
-			const rows = await this.db.selectFrom("content_taxonomies").select(["taxonomy_id", (eb) => eb.fn.count("entry_id").as("count")]).where("taxonomy_id", "in", chunk).groupBy("taxonomy_id").execute();
-			for (const row of rows) counts.set(row.taxonomy_id, Number(row.count || 0));
-		}
-		return counts;
-	}
-	/**
-	* Convert database row to Taxonomy object
-	*/
-	rowToTaxonomy(row) {
-		return {
-			id: row.id,
-			name: row.name,
-			slug: row.slug,
-			label: row.label,
-			parentId: row.parent_id,
-			data: row.data ? JSON.parse(row.data) : null
-		};
-	}
-};
-
-//#endregion
 //#region src/settings/index.ts
 /** Prefix for site settings in the options table */
 const SETTINGS_PREFIX = "site:";
@@ -895,49 +732,78 @@ async function applySeed(db, seed, options = {}) {
 			}
 		}
 	}
-	if (seed.taxonomies) for (const taxonomy of seed.taxonomies) {
-		const existingDef = await db.selectFrom("_emdash_taxonomy_defs").selectAll().where("name", "=", taxonomy.name).executeTakeFirst();
-		if (existingDef) {
-			if (onConflict === "error") throw new Error(`Conflict: taxonomy "${taxonomy.name}" already exists`);
-			if (onConflict === "update") await db.updateTable("_emdash_taxonomy_defs").set({
-				label: taxonomy.label,
-				label_singular: taxonomy.labelSingular ?? null,
-				hierarchical: taxonomy.hierarchical ? 1 : 0,
-				collections: JSON.stringify(taxonomy.collections)
-			}).where("id", "=", existingDef.id).execute();
-		} else {
-			await db.insertInto("_emdash_taxonomy_defs").values({
-				id: ulid(),
-				name: taxonomy.name,
-				label: taxonomy.label,
-				label_singular: taxonomy.labelSingular ?? null,
-				hierarchical: taxonomy.hierarchical ? 1 : 0,
-				collections: JSON.stringify(taxonomy.collections)
-			}).execute();
-			result.taxonomies.created++;
-		}
-		if (taxonomy.terms && taxonomy.terms.length > 0) {
-			const termRepo = new TaxonomyRepository(db);
-			if (taxonomy.hierarchical) await applyHierarchicalTerms(termRepo, taxonomy.name, taxonomy.terms, result, onConflict);
-			else for (const term of taxonomy.terms) {
-				const existing = await termRepo.findBySlug(taxonomy.name, term.slug);
-				if (existing) {
-					if (onConflict === "error") throw new Error(`Conflict: taxonomy term "${term.slug}" in "${taxonomy.name}" already exists`);
-					if (onConflict === "update") {
-						await termRepo.update(existing.id, {
+	if (seed.taxonomies) {
+		const defSeedIdMap = /* @__PURE__ */ new Map();
+		const termSeedIdMap = /* @__PURE__ */ new Map();
+		const fallbackLocale = getI18nConfig()?.defaultLocale ?? "en";
+		for (const taxonomy of seed.taxonomies) {
+			const defLocale = taxonomy.locale ?? fallbackLocale;
+			const existingDef = await db.selectFrom("_emdash_taxonomy_defs").selectAll().where("name", "=", taxonomy.name).where("locale", "=", defLocale).executeTakeFirst();
+			let defId;
+			let defTranslationGroup;
+			if (existingDef) {
+				defId = existingDef.id;
+				defTranslationGroup = existingDef.translation_group ?? existingDef.id;
+				if (onConflict === "error") throw new Error(`Conflict: taxonomy "${taxonomy.name}" (${defLocale}) already exists`);
+				if (onConflict === "update") await db.updateTable("_emdash_taxonomy_defs").set({
+					label: taxonomy.label,
+					label_singular: taxonomy.labelSingular ?? null,
+					hierarchical: taxonomy.hierarchical ? 1 : 0,
+					collections: JSON.stringify(taxonomy.collections)
+				}).where("id", "=", existingDef.id).execute();
+			} else {
+				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: 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
+			});
+			if (taxonomy.terms && taxonomy.terms.length > 0) {
+				const termRepo = new TaxonomyRepository(db);
+				if (taxonomy.hierarchical) await applyHierarchicalTerms(termRepo, taxonomy.name, defLocale, taxonomy.terms, termSeedIdMap, result, onConflict);
+				else for (const term of taxonomy.terms) {
+					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}" (${termLocale}) already exists`);
+						if (onConflict === "update") {
+							await termRepo.update(existing.id, {
+								label: term.label,
+								data: term.description ? { description: term.description } : {}
+							});
+							result.taxonomies.terms++;
+						}
+						if (term.id) termSeedIdMap.set(term.id, existing.id);
+					} else {
+						const translationOf = term.translationOf ? termSeedIdMap.get(term.translationOf) : void 0;
+						const created = await termRepo.create({
+							name: taxonomy.name,
+							slug: term.slug,
 							label: term.label,
-							data: term.description ? { description: term.description } : {}
+							data: term.description ? { description: term.description } : void 0,
+							locale: termLocale,
+							translationOf
 						});
+						if (term.id) termSeedIdMap.set(term.id, created.id);
 						result.taxonomies.terms++;
 					}
-				} else {
-					await termRepo.create({
-						name: taxonomy.name,
-						slug: term.slug,
-						label: term.label,
-						data: term.description ? { description: term.description } : void 0
-					});
-					result.taxonomies.terms++;
 				}
 			}
 		}
@@ -1040,25 +906,45 @@ async function applySeed(db, seed, options = {}) {
 			result.content.created++;
 		}
 	}
-	if (seed.menus) for (const menu of seed.menus) {
-		const existingMenu = await db.selectFrom("_emdash_menus").selectAll().where("name", "=", menu.name).executeTakeFirst();
-		let menuId;
-		if (existingMenu) {
-			menuId = existingMenu.id;
-			await db.deleteFrom("_emdash_menu_items").where("menu_id", "=", menuId).execute();
-		} else {
-			menuId = ulid();
-			await db.insertInto("_emdash_menus").values({
+	if (seed.menus) {
+		const menuSeedIdMap = /* @__PURE__ */ new Map();
+		const itemSeedIdMap = /* @__PURE__ */ new Map();
+		const fallbackLocale = getI18nConfig()?.defaultLocale ?? "en";
+		for (const menu of seed.menus) {
+			const locale = menu.locale ?? fallbackLocale;
+			const existingMenu = await db.selectFrom("_emdash_menus").selectAll().where("name", "=", menu.name).where("locale", "=", locale).executeTakeFirst();
+			let menuId;
+			let translationGroup;
+			if (existingMenu) {
+				menuId = existingMenu.id;
+				translationGroup = existingMenu.translation_group ?? existingMenu.id;
+				await db.deleteFrom("_emdash_menu_items").where("menu_id", "=", menuId).execute();
+			} else {
+				menuId = ulid();
+				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({
+					id: menuId,
+					name: menu.name,
+					label: menu.label,
+					created_at: (/* @__PURE__ */ new Date()).toISOString(),
+					updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+					locale,
+					translation_group: translationGroup
+				}).execute();
+				result.menus.created++;
+			}
+			if (menu.id) menuSeedIdMap.set(menu.id, {
 				id: menuId,
-				name: menu.name,
-				label: menu.label,
-				created_at: (/* @__PURE__ */ new Date()).toISOString(),
-				updated_at: (/* @__PURE__ */ new Date()).toISOString()
-			}).execute();
-			result.menus.created++;
+				translationGroup
+			});
+			const itemCount = await applyMenuItems(db, menuId, locale, menu.items, null, 0, seedIdMap, itemSeedIdMap);
+			result.menus.items += itemCount;
 		}
-		const itemCount = await applyMenuItems(db, menuId, menu.items, null, 0, seedIdMap);
-		result.menus.items += itemCount;
 	}
 	if (seed.redirects) {
 		const redirectRepo = new RedirectRepository(db);
@@ -1157,9 +1043,9 @@ async function applySeed(db, seed, options = {}) {
 			}
 		}
 	}
-	const { invalidateBylineCache } = await import("./bylines-CvJ3PYz2.mjs").then((n) => n.t);
-	const { invalidateRedirectCache } = await import("./cache-C6N_hhN7.mjs").then((n) => n.t);
-	const { invalidateUrlPatternCache } = await import("./query-Cg9ZKRQ0.mjs").then((n) => n.o);
+	const { invalidateBylineCache } = await import("./bylines-DTFI8nDM.mjs").then((n) => n.t);
+	const { invalidateRedirectCache } = await import("./cache-BAJbeoZ8.mjs").then((n) => n.t);
+	const { invalidateUrlPatternCache } = await import("./query-8c_meo_K.mjs").then((n) => n.o);
 	invalidateBylineCache();
 	invalidateRedirectCache();
 	invalidateUrlPatternCache();
@@ -1168,17 +1054,22 @@ async function applySeed(db, seed, options = {}) {
 /**
 * Apply hierarchical taxonomy terms (parents before children)
 */
-async function applyHierarchicalTerms(termRepo, taxonomyName, terms, result, onConflict = "skip") {
+async function applyHierarchicalTerms(termRepo, taxonomyName, defLocale, terms, termSeedIdMap, result, onConflict = "skip") {
 	const slugToId = /* @__PURE__ */ new Map();
 	let remaining = [...terms];
 	let maxPasses = 10;
 	while (remaining.length > 0 && maxPasses > 0) {
 		const processedThisPass = [];
-		for (const term of remaining) if (!term.parent || slugToId.has(term.parent)) {
-			const parentId = term.parent ? slugToId.get(term.parent) : void 0;
-			const existing = await termRepo.findBySlug(taxonomyName, term.slug);
+		for (const term of remaining) {
+			const termLocale = term.locale ?? defLocale;
+			const parentReady = !term.parent || slugToId.has(`${termLocale}::${term.parent}`);
+			const translationReady = !term.translationOf || termSeedIdMap.has(term.translationOf);
+			if (!parentReady || !translationReady) continue;
+			const parentId = term.parent ? slugToId.get(`${termLocale}::${term.parent}`) : void 0;
+			const translationOf = term.translationOf ? termSeedIdMap.get(term.translationOf) : void 0;
+			const existing = await termRepo.findBySlug(taxonomyName, term.slug, termLocale);
 			if (existing) {
-				if (onConflict === "error") throw new Error(`Conflict: taxonomy term "${term.slug}" in "${taxonomyName}" already exists`);
+				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,
@@ -1187,24 +1078,28 @@ async function applyHierarchicalTerms(termRepo, taxonomyName, terms, result, onC
 					});
 					result.taxonomies.terms++;
 				}
-				slugToId.set(term.slug, existing.id);
+				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 } : void 0
+					data: term.description ? { description: term.description } : void 0,
+					locale: termLocale,
+					translationOf
 				});
-				slugToId.set(term.slug, created.id);
+				slugToId.set(`${termLocale}::${term.slug}`, created.id);
+				if (term.id) termSeedIdMap.set(term.id, created.id);
 				result.taxonomies.terms++;
 			}
-			processedThisPass.push(term.slug);
+			processedThisPass.push(term.slug + "::" + termLocale);
 		}
-		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`);
+	if (remaining.length > 0) console.warn(`Could not process ${remaining.length} terms due to missing parents/translations`);
 }
 /**
 * Apply byline credits to a content entry.
@@ -1234,7 +1129,7 @@ async function applyContentTaxonomies(db, collectionSlug, contentId, entry, isUp
 	if (isUpdate) await db.deleteFrom("content_taxonomies").where("collection", "=", collectionSlug).where("entry_id", "=", contentId).execute();
 	if (!entry.taxonomies) {
 		if (isUpdate) {
-			const { invalidateTermCache } = await import("./taxonomies-ZlRtD6AG.mjs").then((n) => n.u);
+			const { invalidateTermCache } = await import("./taxonomies-Bw76xAxo.mjs").then((n) => n.u);
 			invalidateTermCache();
 		}
 		return;
@@ -1246,17 +1141,23 @@ async function applyContentTaxonomies(db, collectionSlug, contentId, entry, isUp
 			if (term) await termRepo.attachToEntry(collectionSlug, contentId, term.id);
 		}
 	}
-	const { invalidateTermCache } = await import("./taxonomies-ZlRtD6AG.mjs").then((n) => n.u);
+	const { invalidateTermCache } = await import("./taxonomies-Bw76xAxo.mjs").then((n) => n.u);
 	invalidateTermCache();
 }
 /**
-* Apply menu items recursively
+* Apply menu items recursively.
+*
+* When a `SeedMenuItem` carries `id`/`translationOf`, the import resolves the
+* source item's `translation_group` so cross-locale "same nav entry" links
+* survive export → apply. Items without `translationOf` get a fresh group
+* (= their own id).
 */
-async function applyMenuItems(db, menuId, items, parentId, startOrder, seedIdMap) {
+async function applyMenuItems(db, menuId, locale, items, parentId, startOrder, seedIdMap, itemSeedIdMap) {
 	let count = 0;
 	let order = startOrder;
 	for (const item of items) {
 		const itemId = ulid();
+		const itemLocale = item.locale ?? locale;
 		let referenceId = null;
 		let referenceCollection = null;
 		if (item.type === "page" || item.type === "post") {
@@ -1265,6 +1166,12 @@ async function applyMenuItems(db, menuId, items, parentId, startOrder, seedIdMap
 				referenceCollection = item.collection || `${item.type}s`;
 			}
 		}
+		let translationGroup = itemId;
+		if (item.translationOf) {
+			const source = itemSeedIdMap.get(item.translationOf);
+			if (source) translationGroup = source.translationGroup;
+			else console.warn(`menu item "${item.label ?? item.url ?? item.ref ?? "(unlabeled)"}" (${itemLocale}): translationOf "${item.translationOf}" not found yet; minting a fresh group.`);
+		}
 		await db.insertInto("_emdash_menu_items").values({
 			id: itemId,
 			menu_id: menuId,
@@ -1278,12 +1185,18 @@ async function applyMenuItems(db, menuId, items, parentId, startOrder, seedIdMap
 			title_attr: item.titleAttr ?? null,
 			target: item.target ?? null,
 			css_classes: item.cssClasses ?? null,
-			created_at: (/* @__PURE__ */ new Date()).toISOString()
+			created_at: (/* @__PURE__ */ new Date()).toISOString(),
+			locale: itemLocale,
+			translation_group: translationGroup
 		}).execute();
+		if (item.id) itemSeedIdMap.set(item.id, {
+			id: itemId,
+			translationGroup
+		});
 		count++;
 		order++;
 		if (item.children && item.children.length > 0) {
-			const childCount = await applyMenuItems(db, menuId, item.children, itemId, 0, seedIdMap);
+			const childCount = await applyMenuItems(db, menuId, itemLocale, item.children, itemId, 0, seedIdMap, itemSeedIdMap);
 			count += childCount;
 		}
 	}
@@ -1474,5 +1387,5 @@ function getImageDimensions(buffer) {
 }
 
 //#endregion
-export { ssrfSafeFetch as a, getPluginSetting as c, getSiteSettings as d, setSiteSettings as f, resolveAndValidateExternalUrl as i, getPluginSettings as l, apply_exports as n, stripCredentialHeaders as o, TaxonomyRepository as p, SsrfError as r, validateExternalUrl as s, applySeed as t, getSiteSetting as u };
-//# sourceMappingURL=apply-BzltprvY.mjs.map
+export { ssrfSafeFetch as a, getPluginSetting as c, getSiteSettings as d, setSiteSettings as f, resolveAndValidateExternalUrl as i, getPluginSettings as l, apply_exports as n, stripCredentialHeaders as o, SsrfError as r, validateExternalUrl as s, applySeed as t, getSiteSetting as u };
+//# sourceMappingURL=apply-Ded_1vng.mjs.map