emdash 1.0.1 → 1.2.0

package/dist/widgets-BkcMzKct.mjs

@@ -0,0 +1,121 @@
+import { n as peekRequestCache, r as requestCached } from "./request-cache-C4CIo5ad.mjs";
+import { i as widgetAreaTag } from "./chrome-tags-BIKBMZYO.mjs";
+import { c as getDb } from "./loader-CetY659y.mjs";
+import { t as getWidgetComponents$1 } from "./components-oFXumpf5.mjs";
+
+//#region src/widgets/index.ts
+/**
+* Get a widget area by name, with all its widgets.
+*/
+async function getWidgetArea(name) {
+	return requestCached(`widget-area:${name}`, async () => {
+		const prefetched = peekRequestCache("widget-areas");
+		if (prefetched) try {
+			return (await prefetched).find((area) => area.name === name) ?? null;
+		} catch {}
+		return groupAreaRows(await selectAreasWithWidgets(await getDb()).where("a.name", "=", name).orderBy("w.sort_order", "asc").execute())[0] ?? null;
+	});
+}
+/**
+* Areas left-joined with their widgets, so areas and widgets load in one
+* round trip. An area with no widgets yields one row with null widget columns.
+*/
+function selectAreasWithWidgets(db) {
+	return db.selectFrom("_emdash_widget_areas as a").leftJoin("_emdash_widgets as w", "w.area_id", "a.id").select([
+		"a.id as a_id",
+		"a.name as a_name",
+		"a.label as a_label",
+		"a.description as a_description",
+		"w.id as w_id",
+		"w.type as w_type",
+		"w.title as w_title",
+		"w.content as w_content",
+		"w.menu_name as w_menu_name",
+		"w.component_id as w_component_id",
+		"w.component_props as w_component_props",
+		"w.area_id as w_area_id",
+		"w.sort_order as w_sort_order",
+		"w.created_at as w_created_at"
+	]);
+}
+/** Group joined rows into areas, keeping row order for areas and widgets. */
+function groupAreaRows(rows) {
+	const areas = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		let area = areas.get(row.a_id);
+		if (!area) {
+			area = {
+				id: row.a_id,
+				name: row.a_name,
+				label: row.a_label,
+				description: row.a_description ?? void 0,
+				widgets: []
+			};
+			areas.set(row.a_id, area);
+		}
+		if (row.w_id === null) continue;
+		const widgetRow = {
+			id: row.w_id,
+			type: row.w_type,
+			title: row.w_title,
+			content: row.w_content,
+			menu_name: row.w_menu_name,
+			component_id: row.w_component_id,
+			component_props: row.w_component_props,
+			area_id: row.w_area_id,
+			sort_order: row.w_sort_order,
+			created_at: row.w_created_at
+		};
+		area.widgets.push(rowToWidget(widgetRow));
+	}
+	return [...areas.values()];
+}
+/**
+* Get a widget area by name with a Workers edge-cache hint.
+*
+* Use the returned `cacheHint` with `Astro.cache.set()` so pages that render
+* this widget area can be purged automatically when its widgets change.
+*/
+async function getWidgetAreaWithCacheHint(name) {
+	return {
+		data: await getWidgetArea(name),
+		cacheHint: { tags: [widgetAreaTag(name)] }
+	};
+}
+/**
+* Get all widget areas with their widgets
+*/
+async function getWidgetAreas() {
+	return groupAreaRows(await selectAreasWithWidgets(await getDb()).orderBy("a.created_at", "asc").orderBy("a.id", "asc").orderBy("w.sort_order", "asc").execute());
+}
+/**
+* Get available widget components (for admin UI)
+*/
+function getWidgetComponents() {
+	return getWidgetComponents$1();
+}
+/**
+* Convert a widget row to the API type
+*/
+function rowToWidget(row) {
+	const widget = {
+		id: row.id,
+		type: row.type,
+		title: row.title ?? void 0
+	};
+	if (row.type === "content" && row.content) try {
+		widget.content = JSON.parse(row.content);
+	} catch {}
+	if (row.type === "menu" && row.menu_name) widget.menuName = row.menu_name;
+	if (row.type === "component" && row.component_id) {
+		widget.componentId = row.component_id;
+		if (row.component_props) try {
+			widget.componentProps = JSON.parse(row.component_props);
+		} catch {}
+	}
+	return widget;
+}
+
+//#endregion
+export { rowToWidget as a, getWidgetComponents as i, getWidgetAreaWithCacheHint as n, getWidgetAreas as r, getWidgetArea as t };
+//# sourceMappingURL=widgets-BkcMzKct.mjs.map

package/dist/widgets-BkcMzKct.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"widgets-BkcMzKct.mjs","names":["getComponentRegistry"],"sources":["../src/widgets/index.ts"],"sourcesContent":["import type { Kysely } from \"kysely\";\n\nimport { widgetAreaTag } from \"../cache/chrome-tags.js\";\nimport type { Database } from \"../database/types.js\";\nimport { getDb } from \"../loader.js\";\nimport type { CacheHint } from \"../query.js\";\nimport { peekRequestCache, requestCached } from \"../request-cache.js\";\nimport { getWidgetComponents as getComponentRegistry } from \"./components.js\";\nimport type { Widget, WidgetArea, WidgetRow, WidgetComponentDef } from \"./types.js\";\n\nexport type {\n\tWidget,\n\tWidgetArea,\n\tWidgetType,\n\tWidgetComponentDef,\n\tPropDef,\n\tCreateWidgetAreaInput,\n\tCreateWidgetInput,\n\tUpdateWidgetInput,\n\tReorderWidgetsInput,\n} from \"./types.js\";\n\n/**\n * Get a widget area by name, with all its widgets.\n */\nexport async function getWidgetArea(name: string): Promise<WidgetArea | null> {\n\treturn requestCached(`widget-area:${name}`, async () => {\n\t\tconst prefetched = peekRequestCache<WidgetArea[]>(\"widget-areas\");\n\t\tif (prefetched) {\n\t\t\ttry {\n\t\t\t\tconst areas = await prefetched;\n\t\t\t\treturn areas.find((area) => area.name === name) ?? null;\n\t\t\t} catch {\n\t\t\t\t// Optional prefetch failure must still allow the scoped read.\n\t\t\t}\n\t\t}\n\n\t\tconst db = await getDb();\n\t\tconst rows = await selectAreasWithWidgets(db)\n\t\t\t.where(\"a.name\", \"=\", name)\n\t\t\t.orderBy(\"w.sort_order\", \"asc\")\n\t\t\t.execute();\n\t\treturn groupAreaRows(rows)[0] ?? null;\n\t});\n}\n\n/**\n * Areas left-joined with their widgets, so areas and widgets load in one\n * round trip. An area with no widgets yields one row with null widget columns.\n */\nfunction selectAreasWithWidgets(db: Kysely<Database>) {\n\treturn db\n\t\t.selectFrom(\"_emdash_widget_areas as a\")\n\t\t.leftJoin(\"_emdash_widgets as w\", \"w.area_id\", \"a.id\")\n\t\t.select([\n\t\t\t\"a.id as a_id\",\n\t\t\t\"a.name as a_name\",\n\t\t\t\"a.label as a_label\",\n\t\t\t\"a.description as a_description\",\n\t\t\t\"w.id as w_id\",\n\t\t\t\"w.type as w_type\",\n\t\t\t\"w.title as w_title\",\n\t\t\t\"w.content as w_content\",\n\t\t\t\"w.menu_name as w_menu_name\",\n\t\t\t\"w.component_id as w_component_id\",\n\t\t\t\"w.component_props as w_component_props\",\n\t\t\t\"w.area_id as w_area_id\",\n\t\t\t\"w.sort_order as w_sort_order\",\n\t\t\t\"w.created_at as w_created_at\",\n\t\t]);\n}\n\ntype AreaWidgetRow = Awaited<\n\tReturnType<ReturnType<typeof selectAreasWithWidgets>[\"execute\"]>\n>[number];\n\n/** Group joined rows into areas, keeping row order for areas and widgets. */\nfunction groupAreaRows(rows: AreaWidgetRow[]): WidgetArea[] {\n\tconst areas = new Map<string, WidgetArea>();\n\tfor (const row of rows) {\n\t\tlet area = areas.get(row.a_id);\n\t\tif (!area) {\n\t\t\tarea = {\n\t\t\t\tid: row.a_id,\n\t\t\t\tname: row.a_name,\n\t\t\t\tlabel: row.a_label,\n\t\t\t\tdescription: row.a_description ?? undefined,\n\t\t\t\twidgets: [],\n\t\t\t};\n\t\t\tareas.set(row.a_id, area);\n\t\t}\n\t\tif (row.w_id === null) continue;\n\t\t// Every w_* column is non-null whenever w_id is set.\n\t\t// eslint-disable-next-line typescript/no-unsafe-type-assertion -- left-join row is non-null when w_id is set; see above\n\t\tconst widgetRow = {\n\t\t\tid: row.w_id,\n\t\t\ttype: row.w_type,\n\t\t\ttitle: row.w_title,\n\t\t\tcontent: row.w_content,\n\t\t\tmenu_name: row.w_menu_name,\n\t\t\tcomponent_id: row.w_component_id,\n\t\t\tcomponent_props: row.w_component_props,\n\t\t\tarea_id: row.w_area_id,\n\t\t\tsort_order: row.w_sort_order,\n\t\t\tcreated_at: row.w_created_at,\n\t\t} as WidgetRow;\n\t\tarea.widgets.push(rowToWidget(widgetRow));\n\t}\n\treturn [...areas.values()];\n}\n\n/**\n * Get a widget area by name with a Workers edge-cache hint.\n *\n * Use the returned `cacheHint` with `Astro.cache.set()` so pages that render\n * this widget area can be purged automatically when its widgets change.\n */\nexport async function getWidgetAreaWithCacheHint(name: string): Promise<{\n\tdata: WidgetArea | null;\n\tcacheHint: CacheHint;\n}> {\n\tconst data = await getWidgetArea(name);\n\treturn { data, cacheHint: { tags: [widgetAreaTag(name)] } };\n}\n\n/**\n * Get all widget areas with their widgets\n */\nexport async function getWidgetAreas(): Promise<WidgetArea[]> {\n\tconst db = await getDb();\n\tconst rows = await selectAreasWithWidgets(db)\n\t\t.orderBy(\"a.created_at\", \"asc\")\n\t\t.orderBy(\"a.id\", \"asc\")\n\t\t.orderBy(\"w.sort_order\", \"asc\")\n\t\t.execute();\n\treturn groupAreaRows(rows);\n}\n\n/**\n * Get available widget components (for admin UI)\n */\nexport function getWidgetComponents(): WidgetComponentDef[] {\n\treturn getComponentRegistry();\n}\n\n/**\n * Convert a widget row to the API type\n */\nexport function rowToWidget(row: WidgetRow): Widget {\n\tconst widget: Widget = {\n\t\tid: row.id,\n\t\ttype: row.type,\n\t\ttitle: row.title ?? undefined,\n\t};\n\n\t// Type-specific fields\n\tif (row.type === \"content\" && row.content) {\n\t\ttry {\n\t\t\twidget.content = JSON.parse(row.content);\n\t\t} catch {\n\t\t\t// Invalid JSON, ignore\n\t\t}\n\t}\n\n\tif (row.type === \"menu\" && row.menu_name) {\n\t\twidget.menuName = row.menu_name;\n\t}\n\n\tif (row.type === \"component\" && row.component_id) {\n\t\twidget.componentId = row.component_id;\n\t\tif (row.component_props) {\n\t\t\ttry {\n\t\t\t\twidget.componentProps = JSON.parse(row.component_props);\n\t\t\t} catch {\n\t\t\t\t// Invalid JSON, ignore\n\t\t\t}\n\t\t}\n\t}\n\n\treturn widget;\n}\n"],"mappings":";;;;;;;;;AAyBA,eAAsB,cAAc,MAA0C;AAC7E,QAAO,cAAc,eAAe,QAAQ,YAAY;EACvD,MAAM,aAAa,iBAA+B,eAAe;AACjE,MAAI,WACH,KAAI;AAEH,WADc,MAAM,YACP,MAAM,SAAS,KAAK,SAAS,KAAK,IAAI;UAC5C;AAUT,SAAO,cAJM,MAAM,uBADR,MAAM,OAAO,CACqB,CAC3C,MAAM,UAAU,KAAK,KAAK,CAC1B,QAAQ,gBAAgB,MAAM,CAC9B,SAAS,CACe,CAAC,MAAM;GAChC;;;;;;AAOH,SAAS,uBAAuB,IAAsB;AACrD,QAAO,GACL,WAAW,4BAA4B,CACvC,SAAS,wBAAwB,aAAa,OAAO,CACrD,OAAO;EACP;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,CAAC;;;AAQJ,SAAS,cAAc,MAAqC;CAC3D,MAAM,wBAAQ,IAAI,KAAyB;AAC3C,MAAK,MAAM,OAAO,MAAM;EACvB,IAAI,OAAO,MAAM,IAAI,IAAI,KAAK;AAC9B,MAAI,CAAC,MAAM;AACV,UAAO;IACN,IAAI,IAAI;IACR,MAAM,IAAI;IACV,OAAO,IAAI;IACX,aAAa,IAAI,iBAAiB;IAClC,SAAS,EAAE;IACX;AACD,SAAM,IAAI,IAAI,MAAM,KAAK;;AAE1B,MAAI,IAAI,SAAS,KAAM;EAGvB,MAAM,YAAY;GACjB,IAAI,IAAI;GACR,MAAM,IAAI;GACV,OAAO,IAAI;GACX,SAAS,IAAI;GACb,WAAW,IAAI;GACf,cAAc,IAAI;GAClB,iBAAiB,IAAI;GACrB,SAAS,IAAI;GACb,YAAY,IAAI;GAChB,YAAY,IAAI;GAChB;AACD,OAAK,QAAQ,KAAK,YAAY,UAAU,CAAC;;AAE1C,QAAO,CAAC,GAAG,MAAM,QAAQ,CAAC;;;;;;;;AAS3B,eAAsB,2BAA2B,MAG9C;AAEF,QAAO;EAAE,MADI,MAAM,cAAc,KAAK;EACvB,WAAW,EAAE,MAAM,CAAC,cAAc,KAAK,CAAC,EAAE;EAAE;;;;;AAM5D,eAAsB,iBAAwC;AAO7D,QAAO,cALM,MAAM,uBADR,MAAM,OAAO,CACqB,CAC3C,QAAQ,gBAAgB,MAAM,CAC9B,QAAQ,QAAQ,MAAM,CACtB,QAAQ,gBAAgB,MAAM,CAC9B,SAAS,CACe;;;;;AAM3B,SAAgB,sBAA4C;AAC3D,QAAOA,uBAAsB;;;;;AAM9B,SAAgB,YAAY,KAAwB;CACnD,MAAM,SAAiB;EACtB,IAAI,IAAI;EACR,MAAM,IAAI;EACV,OAAO,IAAI,SAAS;EACpB;AAGD,KAAI,IAAI,SAAS,aAAa,IAAI,QACjC,KAAI;AACH,SAAO,UAAU,KAAK,MAAM,IAAI,QAAQ;SACjC;AAKT,KAAI,IAAI,SAAS,UAAU,IAAI,UAC9B,QAAO,WAAW,IAAI;AAGvB,KAAI,IAAI,SAAS,eAAe,IAAI,cAAc;AACjD,SAAO,cAAc,IAAI;AACzB,MAAI,IAAI,gBACP,KAAI;AACH,UAAO,iBAAiB,KAAK,MAAM,IAAI,gBAAgB;UAChD;;AAMV,QAAO"}

package/dist/wxr-taxonomies-BxI0CbTg.mjs

@@ -0,0 +1,453 @@
+import { t as TaxonomyRepository } from "./taxonomy-QrNmTfIZ.mjs";
+import { g as selectTaxonomyDefs, p as findTaxonomyStructure } from "./loader-CetY659y.mjs";
+import { d as invalidateTermCache } from "./taxonomies-DQSywBvX.mjs";
+
+//#region src/import/wxr-taxonomies.ts
+/**
+* Thrown by `mirrorTermsToLocales` when a pre-existing locale row at the
+* same `(taxonomy, slug)` belongs to a different `translation_group` than
+* the canonical term. Callers in the route layer surface
+* `publicMessage` to the operator (no internal data) while logging
+* `cause` server-side.
+*
+* Marker class so the route layer can distinguish "operator-actionable
+* taxonomy conflict" from any other DB / repository error that might
+* escape the helper.
+*/
+var WxrTaxonomyConflictError = class extends Error {
+	publicMessage;
+	constructor(publicMessage, options) {
+		super(publicMessage, options);
+		this.name = "WxrTaxonomyConflictError";
+		this.publicMessage = publicMessage;
+	}
+};
+function isWxrTaxonomyConflictError(error) {
+	return error instanceof WxrTaxonomyConflictError;
+}
+function makeState() {
+	return { plan: {
+		termsCreated: {},
+		termsReused: {},
+		missingTaxonomies: [],
+		termIdByNameAndSlug: /* @__PURE__ */ new Map(),
+		collectionsByTaxonomy: /* @__PURE__ */ new Map(),
+		translationGroupByTermId: /* @__PURE__ */ new Map()
+	} };
+}
+/**
+* Record-keeping helpers — keep mutations centralised so the result object
+* stays consistent.
+*/
+function bump(record, key) {
+	record[key] = (record[key] ?? 0) + 1;
+}
+function rememberTerm(state, taxonomyName, slug, termId) {
+	let bySlug = state.plan.termIdByNameAndSlug.get(taxonomyName);
+	if (!bySlug) {
+		bySlug = /* @__PURE__ */ new Map();
+		state.plan.termIdByNameAndSlug.set(taxonomyName, bySlug);
+	}
+	bySlug.set(slug, termId);
+}
+function parseDefCollections(raw) {
+	if (!raw) return [];
+	try {
+		const parsed = JSON.parse(raw);
+		if (Array.isArray(parsed)) return parsed.filter((c) => typeof c === "string");
+	} catch {}
+	return [];
+}
+/**
+* Rebuild the taxonomy lookup maps from the database without creating
+* anything. The chunked WP import runs term creation once (first content
+* chunk); every later chunk only needs the maps to attach per-post
+* assignments, and two SELECTs are far cheaper than re-walking every term
+* through the ensure path.
+*
+* ponytail: first row wins per (name, slug), ordered by locale asc — the
+* same row `findBySlug` without a locale resolves to. Per-locale term
+* variants beyond that are the mirror pass's job, not the importer's.
+*/
+async function loadTaxonomyPlanFromDb(db) {
+	const state = makeState();
+	const defs = await selectTaxonomyDefs(db).orderBy("d.locale", "asc").execute();
+	for (const def of defs) if (!state.plan.collectionsByTaxonomy.has(def.name)) state.plan.collectionsByTaxonomy.set(def.name, new Set(parseDefCollections(def.collections)));
+	const terms = await db.selectFrom("taxonomies").select([
+		"name",
+		"slug",
+		"id"
+	]).orderBy("locale", "asc").execute();
+	for (const term of terms) if (!state.plan.termIdByNameAndSlug.get(term.name)?.has(term.slug)) rememberTerm(state, term.name, term.slug, term.id);
+	return state.plan;
+}
+function termKey(taxonomyName, slug) {
+	return `${taxonomyName}\u0000${slug}`;
+}
+/**
+* Find or create many terms in a small number of batched SELECTs instead of
+* one SELECT per term. This is the dominant fixed cost for WXR imports with
+* large category/tag vocabularies: a site with 100+ categories would otherwise
+* spend one D1 round-trip per category before writing any posts.
+*
+* Batching rules:
+*   - Descriptors already resolved in `state.plan.termIdByNameAndSlug` are
+*     skipped (same idempotency as the old per-term loop).
+*   - Remaining descriptors are deduplicated by `(taxonomy, slug)`; the first
+*     label/description seen wins, matching the old behaviour where the first
+*     `ensureTerm` call cached the id.
+*   - One batched SELECT resolves existing rows at the requested locale.
+*   - One batched SELECT resolves any-locale rows for use as `translationOf`.
+*   - Missing rows are still created one at a time because each insert needs
+*     its own ULID/translation_group/sort_order bookkeeping, but the reads are
+*     where the round-trip bottleneck lives.
+*/
+async function ensureTermsBatch(db, state, descriptors, locale) {
+	if (descriptors.length === 0) return;
+	const repo = new TaxonomyRepository(db);
+	const needed = [];
+	const seenKeys = /* @__PURE__ */ new Set();
+	for (const d of descriptors) {
+		if (state.plan.termIdByNameAndSlug.get(d.taxonomyName)?.has(d.slug)) continue;
+		const key = termKey(d.taxonomyName, d.slug);
+		if (seenKeys.has(key)) continue;
+		seenKeys.add(key);
+		needed.push(d);
+	}
+	if (needed.length === 0) return;
+	const existingAtLocale = await findExistingTerms(db, needed, locale);
+	for (const row of existingAtLocale) {
+		bump(state.plan.termsReused, row.name);
+		rememberTerm(state, row.name, row.slug, row.id);
+	}
+	const stillNeeded = [];
+	for (const d of needed) if (!state.plan.termIdByNameAndSlug.get(d.taxonomyName)?.has(d.slug)) stillNeeded.push(d);
+	if (stillNeeded.length === 0) return;
+	const anyLocaleRows = await findExistingTerms(db, stillNeeded, void 0);
+	const translationOfByKey = /* @__PURE__ */ new Map();
+	for (const row of anyLocaleRows) {
+		const key = termKey(row.name, row.slug);
+		if (!translationOfByKey.has(key)) translationOfByKey.set(key, row.id);
+	}
+	for (const d of stillNeeded) {
+		const created = await repo.create({
+			name: d.taxonomyName,
+			slug: d.slug,
+			label: d.label,
+			data: d.description ? { description: d.description } : void 0,
+			locale,
+			translationOf: translationOfByKey.get(termKey(d.taxonomyName, d.slug))
+		});
+		bump(state.plan.termsCreated, d.taxonomyName);
+		rememberTerm(state, d.taxonomyName, d.slug, created.id);
+	}
+}
+/**
+* Batched lookup of term rows for a list of `(taxonomy, slug)` pairs.
+* Chunks at `SQL_BATCH_SIZE / 2` because each pair consumes two bind
+* parameters (`name` and `slug`). When `locale` is omitted, returns rows
+* for all locales ordered by locale ascending so callers can pick the first
+* row per pair (mirroring `TaxonomyRepository.findBySlug` without a locale
+* argument).
+*/
+async function findExistingTerms(db, descriptors, locale) {
+	const { chunks, SQL_BATCH_SIZE } = await import("./chunks-Dr5Vr0zA.mjs").then((n) => n.r);
+	const rows = [];
+	const seenKeys = /* @__PURE__ */ new Set();
+	for (const batch of chunks(descriptors, Math.floor(SQL_BATCH_SIZE / 2))) {
+		const batchRows = await db.selectFrom("taxonomies").select([
+			"id",
+			"name",
+			"slug"
+		]).where((eb) => eb.or(batch.map((d) => eb.and([eb("name", "=", d.taxonomyName), eb("slug", "=", d.slug)])))).$if(locale !== void 0, (qb) => qb.where("locale", "=", locale)).orderBy("locale", "asc").execute();
+		for (const row of batchRows) {
+			const key = termKey(row.name, row.slug);
+			if (seenKeys.has(key)) continue;
+			seenKeys.add(key);
+			rows.push(row);
+		}
+	}
+	return rows;
+}
+/**
+* Retrieve the human label captured by the parser for a per-item
+* `<category>` text body, falling back to the slug when the parser didn't
+* see a label (e.g. self-closing tags or whitespace-only bodies).
+*/
+function labelFor(post, taxonomy, slug) {
+	const key = `${taxonomy}\u0000${slug}`;
+	return post.taxonomyLabels?.get(key) ?? slug;
+}
+/**
+* Pre-import every term referenced by the WXR file.
+*
+* Pass 1: `wp:category` blocks. Each becomes a term in EmDash's seeded
+*         `category` taxonomy.
+* Pass 2: `wp:tag` blocks. Each becomes a term in `tag`.
+* Pass 3: `wp:term` blocks (custom taxonomies). Skipped when no matching
+*         EmDash def exists.
+* Pass 4: per-item `<category domain="…" nicename="…">` assignments. WXR
+*         exports sometimes reference taxonomies/terms that weren't declared
+*         at the top level (older exports especially), so we backfill terms
+*         from per-item assignments. Categories and tags use the seeded defs
+*         and pick up the assignment text as the label; custom domains fall
+*         back to the same "def must exist" rule.
+*/
+async function preImportWxrTaxonomies(db, posts, categories, tags, terms, locale) {
+	const state = makeState();
+	const defCache = /* @__PURE__ */ new Map();
+	const lookupDef = async (name) => {
+		if (defCache.has(name)) return defCache.get(name) ?? null;
+		const def = await findTaxonomyStructure(db, name);
+		defCache.set(name, def);
+		if (def) state.plan.collectionsByTaxonomy.set(name, new Set(def.collections));
+		return def;
+	};
+	const categoryDef = await lookupDef("category");
+	const tagDef = await lookupDef("tag");
+	const topLevel = [];
+	if (categoryDef) for (const cat of categories) {
+		if (!cat.nicename || !cat.name) continue;
+		topLevel.push({
+			taxonomyName: "category",
+			slug: cat.nicename,
+			label: cat.name,
+			description: cat.description
+		});
+	}
+	else if (categories.length > 0) state.plan.missingTaxonomies.push("category");
+	if (tagDef) for (const tag of tags) {
+		if (!tag.slug || !tag.name) continue;
+		topLevel.push({
+			taxonomyName: "tag",
+			slug: tag.slug,
+			label: tag.name,
+			description: tag.description
+		});
+	}
+	else if (tags.length > 0) state.plan.missingTaxonomies.push("tag");
+	for (const term of terms) {
+		if (term.taxonomy === "nav_menu" || term.taxonomy === "language") continue;
+		const taxonomyName = term.taxonomy === "post_tag" ? "tag" : term.taxonomy;
+		if (!await lookupDef(taxonomyName)) {
+			if (!state.plan.missingTaxonomies.includes(taxonomyName)) state.plan.missingTaxonomies.push(taxonomyName);
+			continue;
+		}
+		topLevel.push({
+			taxonomyName,
+			slug: term.slug,
+			label: term.name,
+			description: term.description
+		});
+	}
+	await ensureTermsBatch(db, state, topLevel, locale);
+	const fromPosts = [];
+	let recordedMissingCategoryFromPosts = false;
+	let recordedMissingTagFromPosts = false;
+	for (const post of posts) {
+		for (const slug of post.categories) {
+			if (!categoryDef) {
+				if (!recordedMissingCategoryFromPosts && !state.plan.missingTaxonomies.includes("category")) {
+					state.plan.missingTaxonomies.push("category");
+					recordedMissingCategoryFromPosts = true;
+				}
+				break;
+			}
+			if (state.plan.termIdByNameAndSlug.get("category")?.has(slug)) continue;
+			fromPosts.push({
+				taxonomyName: "category",
+				slug,
+				label: labelFor(post, "category", slug)
+			});
+		}
+		for (const slug of post.tags) {
+			if (!tagDef) {
+				if (!recordedMissingTagFromPosts && !state.plan.missingTaxonomies.includes("tag")) {
+					state.plan.missingTaxonomies.push("tag");
+					recordedMissingTagFromPosts = true;
+				}
+				break;
+			}
+			if (state.plan.termIdByNameAndSlug.get("tag")?.has(slug)) continue;
+			fromPosts.push({
+				taxonomyName: "tag",
+				slug,
+				label: labelFor(post, "tag", slug)
+			});
+		}
+		if (post.customTaxonomies) for (const [rawName, slugs] of post.customTaxonomies) {
+			if (rawName === "nav_menu" || rawName === "language") continue;
+			const taxonomyName = rawName === "post_tag" ? "tag" : rawName;
+			if (!await lookupDef(taxonomyName)) {
+				if (!state.plan.missingTaxonomies.includes(taxonomyName)) state.plan.missingTaxonomies.push(taxonomyName);
+				continue;
+			}
+			for (const slug of slugs) {
+				if (state.plan.termIdByNameAndSlug.get(taxonomyName)?.has(slug)) continue;
+				fromPosts.push({
+					taxonomyName,
+					slug,
+					label: labelFor(post, taxonomyName, slug)
+				});
+			}
+		}
+	}
+	await ensureTermsBatch(db, state, fromPosts, locale);
+	invalidateTermCache();
+	return state.plan;
+}
+/**
+* Walk a parsed WXR post's per-item taxonomy assignments and return only
+* the ones that resolve to a real EmDash term AND aren't filtered out by
+* the taxonomy def's `collections` allowlist. Grouped by EmDash taxonomy
+* name (so `post_tag` is already folded into `tag`). Deduplicated.
+*
+* This is the single source of truth for "what will the importer try to
+* write for this post". Both the anchor (additive `attachToEntry`) and
+* translation (per-taxonomy `setTermsForEntry`) paths drive from this map
+* so they agree on which taxonomies need touching. In particular, the
+* translation path uses the keys here -- not `postAssignedTaxonomies` --
+* to decide which inherited pivot rows to clear, so a translation whose
+* only assignment is filtered out by `collections` doesn't lose its
+* inherited terms (see #1087 review feedback).
+*
+* Skipped taxonomies: `nav_menu` (handled by the menu importer) and
+* `language` (Polylang's locale signal, already promoted to `post.locale`
+* by the parser).
+*/
+function resolvePostTermAssignments(collection, post, plan) {
+	const result = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const tryResolve = (taxonomyName, slug) => {
+		const termId = plan.termIdByNameAndSlug.get(taxonomyName)?.get(slug);
+		if (!termId) return;
+		const collectionFilter = plan.collectionsByTaxonomy.get(taxonomyName);
+		if (collectionFilter && collectionFilter.size > 0 && !collectionFilter.has(collection)) return;
+		const dedupeKey = `${taxonomyName}\u0000${termId}`;
+		if (seen.has(dedupeKey)) return;
+		seen.add(dedupeKey);
+		const existing = result.get(taxonomyName);
+		if (existing) existing.push(termId);
+		else result.set(taxonomyName, [termId]);
+	};
+	for (const slug of post.categories) tryResolve("category", slug);
+	for (const slug of post.tags) tryResolve("tag", slug);
+	if (post.customTaxonomies) for (const [rawName, slugs] of post.customTaxonomies) {
+		if (rawName === "nav_menu" || rawName === "language") continue;
+		const taxonomyName = rawName === "post_tag" ? "tag" : rawName;
+		for (const slug of slugs) tryResolve(taxonomyName, slug);
+	}
+	return result;
+}
+/**
+* Attach the taxonomy assignments parsed for a single WXR post to a freshly-
+* created EmDash content row. Additive (`attachToEntry` + `ON CONFLICT DO
+* NOTHING`). Used for anchors -- translations need replace-semantics per
+* taxonomy and should use `setPostTermAssignmentsReplacing` instead.
+*
+* Returns the number of pivot rows actually inserted (excludes rows that
+* already existed via the `ON CONFLICT DO NOTHING` path), so the caller can
+* roll them up into the import summary without over-counting on re-imports.
+*/
+async function attachPostTaxonomies(db, collection, entryId, post, plan) {
+	const repo = new TaxonomyRepository(db);
+	const resolved = resolvePostTermAssignments(collection, post, plan);
+	const groups = /* @__PURE__ */ new Set();
+	for (const [, termIds] of resolved) for (const termId of termIds) {
+		const group = await termTranslationGroup(repo, plan, termId);
+		if (group) groups.add(group);
+	}
+	return repo.attachGroupsToEntry(collection, entryId, [...groups]);
+}
+/**
+* Replace assignments per-taxonomy from a parsed WXR post. Used for
+* translations. Assignments belong to the content translation_group, so a
+* translated item's explicit taxonomy replaces that taxonomy for every
+* locale. Taxonomies with no resolvable permitted terms are left unchanged.
+*
+* Returns the number of pivot rows after replacement (sum of `termIds`
+* lists across taxonomies actually touched). Note this counts logical
+* assignments, not the delta from the prior state; the import summary
+* treats this as an additive count for compatibility with `attachPost-
+* Taxonomies`.
+*/
+async function setPostTermAssignmentsReplacing(db, collection, entryId, post, plan) {
+	const repo = new TaxonomyRepository(db);
+	const resolved = resolvePostTermAssignments(collection, post, plan);
+	let attached = 0;
+	for (const [taxonomyName, termIds] of resolved) {
+		await repo.setTermsForEntry(collection, entryId, taxonomyName, termIds);
+		attached += termIds.length;
+	}
+	return attached;
+}
+/**
+* Resolve a term id to its `translation_group` (the value
+* `content_taxonomies` stores). Caches the result on the plan so
+* repeated attaches of the same term don't repeat the lookup.
+*/
+async function termTranslationGroup(repo, plan, termId) {
+	const cached = plan.translationGroupByTermId.get(termId);
+	if (cached !== void 0) return cached;
+	const group = (await repo.findById(termId))?.translationGroup ?? null;
+	plan.translationGroupByTermId.set(termId, group);
+	return group;
+}
+/**
+* Mirror every term in the plan into each additional locale used by the
+* incoming posts. New rows share the canonical term's `translation_group`
+* so per-locale lookups (`getTermsForEntry(..., locale)`) resolve correctly
+* for translations whose locale differs from the import-wide one.
+*
+* Without this pass, multilingual WXR imports (#1080) write all term rows
+* at the upload-wide locale; the `content_taxonomies` pivot is correct (it
+* stores `translation_group`, not `term id`), but
+* `getTermsForEntry(collection, arabicPostId, "category", "ar")` filters on
+* `taxonomies.locale = "ar"` and returns zero rows. Users see "no tags" on
+* every non-canonical translation.
+*
+* Idempotent: skips a locale when a row already exists at `(name, slug,
+* locale)`. Safe to call after `preImportWxrTaxonomies` on subsequent
+* imports.
+*/
+async function mirrorTermsToLocales(db, plan, postLocales, canonicalLocale) {
+	const localeSet = /* @__PURE__ */ new Set();
+	for (const locale of postLocales) {
+		if (!locale || locale === canonicalLocale) continue;
+		localeSet.add(locale);
+	}
+	if (localeSet.size === 0) return;
+	const repo = new TaxonomyRepository(db);
+	for (const [taxonomyName, bySlug] of plan.termIdByNameAndSlug) for (const [slug, canonicalTermId] of bySlug) {
+		const cachedGroup = await termTranslationGroup(repo, plan, canonicalTermId);
+		if (!cachedGroup) continue;
+		const canonicalGroup = cachedGroup;
+		for (const locale of localeSet) {
+			const existing = await repo.findBySlug(taxonomyName, slug, locale);
+			if (existing) {
+				if (existing.translationGroup !== canonicalGroup) throw new WxrTaxonomyConflictError(`Cannot import: term "${taxonomyName}/${slug}" already exists at locale "${locale}" in a different translation group than the canonical row at this import's locale. Reconcile the rows in the admin (re-link via translationOf, or delete one) and retry.`);
+				continue;
+			}
+			try {
+				await repo.create({
+					name: taxonomyName,
+					slug,
+					label: slug,
+					locale,
+					translationOf: canonicalTermId
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message.toLowerCase() : "";
+				if (!(message.includes("unique constraint failed") || message.includes("duplicate key"))) throw error;
+				const winner = await repo.findBySlug(taxonomyName, slug, locale);
+				if (!winner) throw new WxrTaxonomyConflictError(`Cannot import: term "${taxonomyName}/${slug}" raced UNIQUE at locale "${locale}" but no row is visible afterwards. The concurrent transaction may have rolled back; retry the import.`, { cause: error });
+				if (winner.translationGroup !== canonicalGroup) throw new WxrTaxonomyConflictError(`Cannot import: term "${taxonomyName}/${slug}" raced UNIQUE at locale "${locale}" with a different translation group. Reconcile the rows in the admin and retry.`, { cause: error });
+				console.warn(`[WXR import] concurrent writer beat us to term "${taxonomyName}/${slug}" at locale "${locale}"; using existing row (same group).`);
+			}
+		}
+	}
+}
+
+//#endregion
+export { preImportWxrTaxonomies as a, mirrorTermsToLocales as i, isWxrTaxonomyConflictError as n, setPostTermAssignmentsReplacing as o, loadTaxonomyPlanFromDb as r, attachPostTaxonomies as t };
+//# sourceMappingURL=wxr-taxonomies-BxI0CbTg.mjs.map