emdash 1.1.0 → 1.2.0

package/dist/widgets-BkxBAgZ_.mjs

@@ -1,126 +0,0 @@
-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-1DMiOq5s.mjs";
-import { t as getWidgetComponents$1 } from "./components-CQY-Sgm-.mjs";
-
-//#region src/widgets/index.ts
-/**
-* Get a widget area by name, with all its widgets.
-*
-* Single query with a left join rather than area-then-widgets so the
-* common case costs one round-trip. An area with no widgets yields one
-* row with null widget columns, which we skip when mapping.
-*/
-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 {}
-		const rows = await (await getDb()).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"
-		]).where("a.name", "=", name).orderBy("w.sort_order", "asc").execute();
-		const first = rows[0];
-		if (!first) return null;
-		const widgets = [];
-		for (const row of rows) {
-			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
-			};
-			widgets.push(rowToWidget(widgetRow));
-		}
-		return {
-			id: first.a_id,
-			name: first.a_name,
-			label: first.a_label,
-			description: first.a_description ?? void 0,
-			widgets
-		};
-	});
-}
-/**
-* 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() {
-	const db = await getDb();
-	const areaRows = await db.selectFrom("_emdash_widget_areas").selectAll().execute();
-	const widgetRows = await db.selectFrom("_emdash_widgets").selectAll().$castTo().orderBy("sort_order", "asc").execute();
-	const widgetsByArea = /* @__PURE__ */ new Map();
-	for (const row of widgetRows) {
-		if (!widgetsByArea.has(row.area_id)) widgetsByArea.set(row.area_id, []);
-		widgetsByArea.get(row.area_id).push(rowToWidget(row));
-	}
-	return areaRows.map((areaRow) => ({
-		id: areaRow.id,
-		name: areaRow.name,
-		label: areaRow.label,
-		description: areaRow.description ?? void 0,
-		widgets: widgetsByArea.get(areaRow.id) || []
-	}));
-}
-/**
-* 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-BkxBAgZ_.mjs.map

package/dist/widgets-BkxBAgZ_.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"widgets-BkxBAgZ_.mjs","names":["getComponentRegistry"],"sources":["../src/widgets/index.ts"],"sourcesContent":["import { widgetAreaTag } from \"../cache/chrome-tags.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 *\n * Single query with a left join rather than area-then-widgets so the\n * common case costs one round-trip. An area with no widgets yields one\n * row with null widget columns, which we skip when mapping.\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 db\n\t\t\t.selectFrom(\"_emdash_widget_areas as a\")\n\t\t\t.leftJoin(\"_emdash_widgets as w\", \"w.area_id\", \"a.id\")\n\t\t\t.select([\n\t\t\t\t\"a.id as a_id\",\n\t\t\t\t\"a.name as a_name\",\n\t\t\t\t\"a.label as a_label\",\n\t\t\t\t\"a.description as a_description\",\n\t\t\t\t\"w.id as w_id\",\n\t\t\t\t\"w.type as w_type\",\n\t\t\t\t\"w.title as w_title\",\n\t\t\t\t\"w.content as w_content\",\n\t\t\t\t\"w.menu_name as w_menu_name\",\n\t\t\t\t\"w.component_id as w_component_id\",\n\t\t\t\t\"w.component_props as w_component_props\",\n\t\t\t\t\"w.area_id as w_area_id\",\n\t\t\t\t\"w.sort_order as w_sort_order\",\n\t\t\t\t\"w.created_at as w_created_at\",\n\t\t\t])\n\t\t\t.where(\"a.name\", \"=\", name)\n\t\t\t.orderBy(\"w.sort_order\", \"asc\")\n\t\t\t.execute();\n\n\t\tconst first = rows[0];\n\t\tif (!first) return null;\n\t\tconst widgets: Widget[] = [];\n\t\tfor (const row of rows) {\n\t\t\tif (row.w_id === null) continue; // area has no widgets (left-join null row)\n\t\t\t// Left-join makes every w_* column nullable in the type; at runtime\n\t\t\t// they're all non-null once w_id is (we match on widgets.area_id, so\n\t\t\t// a widget row always has the not-null columns filled). Cast is the\n\t\t\t// price of that structural fact.\n\t\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\t\tconst widgetRow = {\n\t\t\t\tid: row.w_id,\n\t\t\t\ttype: row.w_type,\n\t\t\t\ttitle: row.w_title,\n\t\t\t\tcontent: row.w_content,\n\t\t\t\tmenu_name: row.w_menu_name,\n\t\t\t\tcomponent_id: row.w_component_id,\n\t\t\t\tcomponent_props: row.w_component_props,\n\t\t\t\tarea_id: row.w_area_id,\n\t\t\t\tsort_order: row.w_sort_order,\n\t\t\t\tcreated_at: row.w_created_at,\n\t\t\t} as WidgetRow;\n\t\t\twidgets.push(rowToWidget(widgetRow));\n\t\t}\n\n\t\treturn {\n\t\t\tid: first.a_id,\n\t\t\tname: first.a_name,\n\t\t\tlabel: first.a_label,\n\t\t\tdescription: first.a_description ?? undefined,\n\t\t\twidgets,\n\t\t};\n\t});\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\t// Get all areas\n\tconst areaRows = await db.selectFrom(\"_emdash_widget_areas\").selectAll().execute();\n\n\t// Get all widgets\n\tconst widgetRows = await db\n\t\t.selectFrom(\"_emdash_widgets\")\n\t\t.selectAll()\n\t\t.$castTo<WidgetRow>()\n\t\t.orderBy(\"sort_order\", \"asc\")\n\t\t.execute();\n\n\t// Group widgets by area\n\tconst widgetsByArea = new Map<string, Widget[]>();\n\tfor (const row of widgetRows) {\n\t\tif (!widgetsByArea.has(row.area_id)) {\n\t\t\twidgetsByArea.set(row.area_id, []);\n\t\t}\n\t\twidgetsByArea.get(row.area_id)!.push(rowToWidget(row));\n\t}\n\n\t// Combine\n\treturn areaRows.map((areaRow) => ({\n\t\tid: areaRow.id,\n\t\tname: areaRow.name,\n\t\tlabel: areaRow.label,\n\t\tdescription: areaRow.description ?? undefined,\n\t\twidgets: widgetsByArea.get(areaRow.id) || [],\n\t}));\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":";;;;;;;;;;;;;AA0BA,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;EAMT,MAAM,OAAO,OADF,MAAM,OAAO,EAEtB,WAAW,4BAA4B,CACvC,SAAS,wBAAwB,aAAa,OAAO,CACrD,OAAO;GACP;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA;GACA,CAAC,CACD,MAAM,UAAU,KAAK,KAAK,CAC1B,QAAQ,gBAAgB,MAAM,CAC9B,SAAS;EAEX,MAAM,QAAQ,KAAK;AACnB,MAAI,CAAC,MAAO,QAAO;EACnB,MAAM,UAAoB,EAAE;AAC5B,OAAK,MAAM,OAAO,MAAM;AACvB,OAAI,IAAI,SAAS,KAAM;GAMvB,MAAM,YAAY;IACjB,IAAI,IAAI;IACR,MAAM,IAAI;IACV,OAAO,IAAI;IACX,SAAS,IAAI;IACb,WAAW,IAAI;IACf,cAAc,IAAI;IAClB,iBAAiB,IAAI;IACrB,SAAS,IAAI;IACb,YAAY,IAAI;IAChB,YAAY,IAAI;IAChB;AACD,WAAQ,KAAK,YAAY,UAAU,CAAC;;AAGrC,SAAO;GACN,IAAI,MAAM;GACV,MAAM,MAAM;GACZ,OAAO,MAAM;GACb,aAAa,MAAM,iBAAiB;GACpC;GACA;GACA;;;;;;;;AASH,eAAsB,2BAA2B,MAG9C;AAEF,QAAO;EAAE,MADI,MAAM,cAAc,KAAK;EACvB,WAAW,EAAE,MAAM,CAAC,cAAc,KAAK,CAAC,EAAE;EAAE;;;;;AAM5D,eAAsB,iBAAwC;CAC7D,MAAM,KAAK,MAAM,OAAO;CAExB,MAAM,WAAW,MAAM,GAAG,WAAW,uBAAuB,CAAC,WAAW,CAAC,SAAS;CAGlF,MAAM,aAAa,MAAM,GACvB,WAAW,kBAAkB,CAC7B,WAAW,CACX,SAAoB,CACpB,QAAQ,cAAc,MAAM,CAC5B,SAAS;CAGX,MAAM,gCAAgB,IAAI,KAAuB;AACjD,MAAK,MAAM,OAAO,YAAY;AAC7B,MAAI,CAAC,cAAc,IAAI,IAAI,QAAQ,CAClC,eAAc,IAAI,IAAI,SAAS,EAAE,CAAC;AAEnC,gBAAc,IAAI,IAAI,QAAQ,CAAE,KAAK,YAAY,IAAI,CAAC;;AAIvD,QAAO,SAAS,KAAK,aAAa;EACjC,IAAI,QAAQ;EACZ,MAAM,QAAQ;EACd,OAAO,QAAQ;EACf,aAAa,QAAQ,eAAe;EACpC,SAAS,cAAc,IAAI,QAAQ,GAAG,IAAI,EAAE;EAC5C,EAAE;;;;;AAMJ,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-D7gAJyOF.mjs

@@ -1,453 +0,0 @@
-import { t as TaxonomyRepository } from "./taxonomy-XzLE95Vx.mjs";
-import { g as selectTaxonomyDefs, p as findTaxonomyStructure } from "./loader-1DMiOq5s.mjs";
-import { d as invalidateTermCache } from "./taxonomies-DAZU9VDd.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-zlGB5IQP.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-D7gAJyOF.mjs.map