dineway 0.1.48 → 0.2.0

package/dist/import-Bh9biJfx.mjs

@@ -0,0 +1,1354 @@
+import { n as slugify } from "./slugify-KSsVD_D3.mjs";
+import { t as TaxonomyRepository } from "./taxonomy-Dvsw6BOs.mjs";
+import { t as OptionsRepository } from "./options-DQPTH5n0.mjs";
+import { o as invalidateSiteSettingsCache } from "./settings-BbqgHWpU.mjs";
+import { i as resolveLocaleChain } from "./resolve-Cb6Dbz-C.mjs";
+import { l as invalidateTermCache } from "./taxonomies-DRiixp_E.mjs";
+import { n as parseWxrString } from "./parser-C1nYd-81.mjs";
+import { a as validateExternalUrl, n as resolveAndValidateExternalUrl, r as ssrfSafeFetch } from "./ssrf-DWe8jwAp.mjs";
+import { _ as sanitizeFieldSlug, a as getFilenameFromUrl, c as isInternalMetaKey, d as mapMetaKeyToField, f as mapPostTypeToCollection, h as relativizeContentLinks, i as checkSchemaCompatibility, l as isInternalPostType, m as normalizeUrl$1, n as FEATURED_IMAGE_FIELD, o as guessMimeType, p as mapWpStatus, r as buildAttachmentMap, s as inferMetaType, t as BASE_REQUIRED_FIELDS, u as isPluginBookkeepingMeta } from "./utils-CMDhr5Xd.mjs";
+import { ulid } from "ulidx";
+import { gutenbergToPortableText } from "@dineway-ai/gutenberg-to-portable-text";
+
+//#region src/import/menus.ts
+/**
+* Import navigation menus from Plugin API
+*
+* @param menus - Menus from plugin API
+* @param db - Database connection
+* @param contentIdMap - Map from WP post ID to Dineway content ID
+* @returns Import result with counts and ID mapping
+*/
+async function importMenusFromPlugin(menus, db, contentIdMap) {
+	const result = {
+		menusCreated: 0,
+		itemsCreated: 0,
+		menuIdMap: /* @__PURE__ */ new Map(),
+		errors: []
+	};
+	for (const menu of menus) try {
+		const existing = await db.selectFrom("_dineway_menus").select("id").where("name", "=", menu.name).executeTakeFirst();
+		if (existing) {
+			result.menuIdMap.set(menu.name, existing.id);
+			continue;
+		}
+		const menuId = ulid();
+		await db.insertInto("_dineway_menus").values({
+			id: menuId,
+			name: menu.name,
+			label: menu.label,
+			translation_group: menuId
+		}).execute();
+		result.menusCreated++;
+		result.menuIdMap.set(menu.name, menuId);
+		const itemsCreated = await importPluginMenuItems(menu.items, menuId, db, contentIdMap);
+		result.itemsCreated += itemsCreated;
+	} catch (error) {
+		result.errors.push({
+			menu: menu.name,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return result;
+}
+/**
+* Import menu items from Plugin API format
+*/
+async function importPluginMenuItems(items, menuId, db, contentIdMap) {
+	const itemIdMap = /* @__PURE__ */ new Map();
+	let count = 0;
+	const sortedItems = items.toSorted((a, b) => a.sort_order - b.sort_order);
+	for (const item of sortedItems) {
+		const itemId = ulid();
+		itemIdMap.set(item.id, itemId);
+		const { type, collection, referenceId, customUrl } = mapPluginMenuItem(item, contentIdMap);
+		await db.insertInto("_dineway_menu_items").values({
+			id: itemId,
+			menu_id: menuId,
+			parent_id: null,
+			sort_order: item.sort_order,
+			type,
+			reference_collection: collection,
+			reference_id: referenceId,
+			custom_url: customUrl,
+			label: item.title,
+			title_attr: null,
+			target: item.target || null,
+			css_classes: item.classes || null,
+			translation_group: itemId
+		}).execute();
+		count++;
+	}
+	for (const item of sortedItems) if (item.parent_id) {
+		const itemId = itemIdMap.get(item.id);
+		const parentId = itemIdMap.get(item.parent_id);
+		if (itemId && parentId) await db.updateTable("_dineway_menu_items").set({ parent_id: parentId }).where("id", "=", itemId).execute();
+	}
+	return count;
+}
+/**
+* Map Plugin menu item to Dineway format
+*/
+function mapPluginMenuItem(item, contentIdMap) {
+	switch (item.type) {
+		case "custom": return {
+			type: "custom",
+			collection: null,
+			referenceId: null,
+			customUrl: item.url || "#"
+		};
+		case "post_type": {
+			const collection = mapObjectToCollection(item.object);
+			const referenceId = item.object_id ? contentIdMap.get(item.object_id) || null : null;
+			if (!referenceId && item.url) return {
+				type: "custom",
+				collection: null,
+				referenceId: null,
+				customUrl: item.url
+			};
+			return {
+				type: collection === "pages" ? "page" : "post",
+				collection,
+				referenceId,
+				customUrl: null
+			};
+		}
+		case "taxonomy": return {
+			type: "custom",
+			collection: null,
+			referenceId: null,
+			customUrl: item.url || "#"
+		};
+		default: return {
+			type: "custom",
+			collection: null,
+			referenceId: null,
+			customUrl: item.url || "#"
+		};
+	}
+}
+/**
+* Map WordPress object type to Dineway collection name
+*/
+function mapObjectToCollection(objectType) {
+	if (!objectType) return "posts";
+	return {
+		post: "posts",
+		page: "pages",
+		product: "products",
+		portfolio: "portfolio"
+	}[objectType] || objectType;
+}
+
+//#endregion
+//#region src/import/comments.ts
+/**
+* Import comments from the plugin API.
+*
+* Preserves original timestamps and threading. Comments whose post was
+* not imported (no entry in `contentIdMap`) are skipped. Re-running the
+* import is idempotent: a comment with the same post, author email,
+* timestamp, and body is not created twice.
+*
+* @param comments - Comments from the plugin API (all pages, flat)
+* @param db - Database connection
+* @param contentIdMap - WP post ID -> Dineway content ID
+* @param collectionMap - WP post ID -> Dineway collection slug
+*/
+async function importCommentsFromPlugin(comments, db, contentIdMap, collectionMap) {
+	const result = {
+		imported: 0,
+		skipped: 0,
+		errors: []
+	};
+	const rootIdMap = /* @__PURE__ */ new Map();
+	const sorted = comments.toSorted((a, b) => a.id - b.id);
+	for (const comment of sorted) {
+		const label = `${comment.author_name || "Anonymous"} (${comment.date_gmt})`;
+		try {
+			const contentId = contentIdMap.get(comment.post_id);
+			const collection = collectionMap.get(comment.post_id);
+			if (!contentId || !collection) {
+				result.skipped++;
+				continue;
+			}
+			const parsed = new Date(comment.date_gmt);
+			const createdAt = Number.isNaN(parsed.getTime()) ? (/* @__PURE__ */ new Date()).toISOString() : parsed.toISOString();
+			const existing = await db.selectFrom("_dineway_comments").select("id").where("content_id", "=", contentId).where("author_email", "=", comment.author_email).where("created_at", "=", createdAt).where("body", "=", comment.body).executeTakeFirst();
+			const parentId = comment.parent_id !== null ? rootIdMap.get(comment.parent_id) ?? null : null;
+			if (existing) {
+				rootIdMap.set(comment.id, parentId ?? existing.id);
+				result.skipped++;
+				continue;
+			}
+			const id = ulid();
+			await db.insertInto("_dineway_comments").values({
+				id,
+				collection,
+				content_id: contentId,
+				parent_id: parentId,
+				author_name: comment.author_name || "Anonymous",
+				author_email: comment.author_email,
+				author_user_id: null,
+				body: comment.body,
+				status: comment.status,
+				ip_hash: null,
+				user_agent: null,
+				moderation_metadata: null,
+				created_at: createdAt,
+				updated_at: createdAt
+			}).execute();
+			rootIdMap.set(comment.id, parentId ?? id);
+			result.imported++;
+		} catch (error) {
+			result.errors.push({
+				comment: label,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/import/sections.ts
+/**
+* Import reusable blocks (wp_block post type) from WXR as sections
+*
+* @param posts - All posts from WXR (will filter to wp_block)
+* @param db - Database connection
+* @returns Import result with counts
+*/
+async function importReusableBlocksAsSections(posts, db) {
+	const result = {
+		sectionsCreated: 0,
+		sectionsSkipped: 0,
+		errors: []
+	};
+	const reusableBlocks = posts.filter((post) => post.postType === "wp_block");
+	if (reusableBlocks.length === 0) return result;
+	for (const block of reusableBlocks) try {
+		const slug = block.postName || slugify(block.title || `block-${block.id || Date.now()}`);
+		if (await db.selectFrom("_dineway_sections").select("id").where("slug", "=", slug).executeTakeFirst()) {
+			result.sectionsSkipped++;
+			continue;
+		}
+		const content = block.content ? gutenbergToPortableText(block.content) : [];
+		const id = ulid();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		await db.insertInto("_dineway_sections").values({
+			id,
+			slug,
+			title: block.title || "Untitled Block",
+			description: null,
+			keywords: null,
+			content: JSON.stringify(content),
+			preview_media_id: null,
+			source: "import",
+			theme_id: null,
+			created_at: now,
+			updated_at: now
+		}).execute();
+		result.sectionsCreated++;
+	} catch (error) {
+		result.errors.push({
+			title: block.title || "Untitled Block",
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return result;
+}
+
+//#endregion
+//#region src/import/settings.ts
+/** Options key prefix used by the site settings module (`settings/index.ts`). */
+const SETTINGS_PREFIX = "site:";
+/**
+* Import site settings from analysis into Dineway site settings.
+*
+* Writes the `site:*` options consumed by `getSiteSettings()` and invalidates
+* the settings cache. Logo/favicon are only applied when the caller resolved
+* them to Dineway media IDs.
+*
+* @param settings - Site settings analysis
+* @param db - Database connection
+* @param overwrite - Whether to overwrite existing settings
+* @param media - Resolved media IDs for logo/favicon
+*/
+async function importSiteSettings(settings, db, overwrite = false, media = {}) {
+	const result = {
+		applied: [],
+		skipped: [],
+		errors: []
+	};
+	const updates = [];
+	if (settings.title) updates.push({
+		setting: "title",
+		value: settings.title
+	});
+	if (settings.tagline) updates.push({
+		setting: "tagline",
+		value: settings.tagline
+	});
+	if (media.logoMediaId) updates.push({
+		setting: "logo",
+		value: { mediaId: media.logoMediaId }
+	});
+	if (media.faviconMediaId) updates.push({
+		setting: "favicon",
+		value: { mediaId: media.faviconMediaId }
+	});
+	if (updates.length === 0) return result;
+	const options = new OptionsRepository(db);
+	try {
+		for (const { setting, value } of updates) try {
+			const key = `${SETTINGS_PREFIX}${setting}`;
+			if (!overwrite) {
+				if (await options.get(key) !== null) {
+					result.skipped.push(setting);
+					continue;
+				}
+			}
+			await options.set(key, value);
+			result.applied.push(setting);
+		} catch (error) {
+			result.errors.push({
+				setting,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	} finally {
+		if (result.applied.length > 0) invalidateSiteSettingsCache();
+	}
+	return result;
+}
+/**
+* Parse site settings from WordPress plugin options response.
+*/
+function parseSiteSettingsFromPlugin(options) {
+	const settings = {};
+	if (typeof options.blogname === "string" && options.blogname.trim() !== "") settings.title = options.blogname;
+	if (typeof options.blogdescription === "string" && options.blogdescription.trim() !== "") settings.tagline = options.blogdescription;
+	if (typeof options.custom_logo_url === "string" && options.custom_logo_url !== "") settings.logo = {
+		url: options.custom_logo_url,
+		id: typeof options.custom_logo === "number" ? options.custom_logo : void 0
+	};
+	if (typeof options.site_icon_url === "string" && options.site_icon_url !== "") settings.favicon = {
+		url: options.site_icon_url,
+		id: typeof options.site_icon === "number" ? options.site_icon : void 0
+	};
+	return settings;
+}
+
+//#endregion
+//#region src/import/registry.ts
+/**
+* Import source registry
+*
+* Manages available import sources and provides URL probing.
+*/
+const TRAILING_SLASHES_PATTERN = /\/+$/;
+/** Registered import sources */
+const sources = /* @__PURE__ */ new Map();
+/**
+* Register an import source
+*/
+function registerSource(source) {
+	sources.set(source.id, source);
+}
+/**
+* Get a source by ID
+*/
+function getSource(id) {
+	return sources.get(id);
+}
+/**
+* Get all registered sources
+*/
+function getAllSources() {
+	return [...sources.values()];
+}
+/**
+* Get sources that can handle file uploads
+*/
+function getFileSources() {
+	return getAllSources().filter((s) => s.requiresFile);
+}
+/**
+* Get sources that can probe URLs
+*/
+function getUrlSources() {
+	return getAllSources().filter((s) => s.canProbe);
+}
+/**
+* Probe a URL against all registered sources
+*
+* Returns probe results sorted by confidence (definite > likely > possible)
+*/
+async function probeUrl(url) {
+	let normalizedUrl = url.trim();
+	if (!normalizedUrl.startsWith("http")) normalizedUrl = `https://${normalizedUrl}`;
+	normalizedUrl = normalizedUrl.replace(TRAILING_SLASHES_PATTERN, "");
+	await resolveAndValidateExternalUrl(normalizedUrl);
+	const results = [];
+	const probePromises = getUrlSources().map(async (source) => {
+		try {
+			const result = await source.probe?.(normalizedUrl);
+			if (result) return result;
+		} catch (error) {
+			console.debug(`Probe failed for ${source.id}:`, error);
+		}
+		return null;
+	});
+	const probeResults = await Promise.allSettled(probePromises);
+	for (const result of probeResults) if (result.status === "fulfilled" && result.value) results.push(result.value);
+	const confidenceOrder = {
+		definite: 0,
+		likely: 1,
+		possible: 2
+	};
+	results.sort((a, b) => confidenceOrder[a.confidence] - confidenceOrder[b.confidence]);
+	return {
+		url: normalizedUrl,
+		isWordPress: results.length > 0,
+		bestMatch: results[0] ?? null,
+		allMatches: results
+	};
+}
+/**
+* Clear all registered sources (useful for testing)
+*/
+function clearSources() {
+	sources.clear();
+}
+
+//#endregion
+//#region src/import/sources/wxr.ts
+/**
+* WXR (WordPress eXtended RSS) import source
+*
+* Handles WordPress export file uploads (.xml).
+* This wraps the existing WXR parsing and analysis logic.
+*/
+const wxrSource = {
+	id: "wxr",
+	name: "WordPress Export File",
+	description: "Upload a WordPress export file (.xml)",
+	icon: "upload",
+	requiresFile: true,
+	canProbe: false,
+	async analyze(input, context) {
+		if (input.type !== "file") throw new Error("WXR source requires a file input");
+		return analyzeWxrData(await parseWxrString(await input.file.text()), context.getExistingCollections ? await context.getExistingCollections() : /* @__PURE__ */ new Map());
+	},
+	async *fetchContent(input, options) {
+		if (input.type !== "file") throw new Error("WXR source requires a file input");
+		const wxr = await parseWxrString(await input.file.text());
+		const attachmentMap = buildAttachmentMap(wxr.attachments);
+		let count = 0;
+		for (const post of wxr.posts) {
+			const postType = post.postType || "post";
+			if (!options.postTypes.includes(postType)) continue;
+			if (isInternalPostType(postType)) continue;
+			if (!options.includeDrafts && post.status !== "publish") continue;
+			yield wxrPostToNormalizedItem(post, attachmentMap, wxr.site.link || "");
+			count++;
+			if (options.limit && count >= options.limit) break;
+		}
+	}
+};
+/**
+* Analyze WXR data and return normalized ImportAnalysis
+*/
+function analyzeWxrData(wxr, existingCollections) {
+	const postTypeCounts = /* @__PURE__ */ new Map();
+	const postTypesWithThumbnails = /* @__PURE__ */ new Set();
+	const metaKeys = /* @__PURE__ */ new Map();
+	const authorPostCounts = /* @__PURE__ */ new Map();
+	for (const post of wxr.posts) {
+		const type = post.postType || "post";
+		postTypeCounts.set(type, (postTypeCounts.get(type) || 0) + 1);
+		if (post.creator) authorPostCounts.set(post.creator, (authorPostCounts.get(post.creator) || 0) + 1);
+		if (post.meta.has("_thumbnail_id")) postTypesWithThumbnails.add(type);
+		for (const [key, value] of post.meta) {
+			const existing = metaKeys.get(key);
+			if (existing) {
+				existing.count++;
+				if (existing.samples.length < 3 && value) existing.samples.push(value.slice(0, 100));
+			} else metaKeys.set(key, {
+				count: 1,
+				samples: value ? [value.slice(0, 100)] : [],
+				isInternal: isInternalMetaKey(key)
+			});
+		}
+	}
+	const customFields = [...metaKeys.entries()].filter(([_, info]) => !info.isInternal).map(([key, info]) => ({
+		key,
+		count: info.count,
+		samples: info.samples,
+		suggestedField: mapMetaKeyToField(key),
+		suggestedType: inferMetaType(key, info.samples[0]),
+		isInternal: info.isInternal
+	})).toSorted((a, b) => b.count - a.count);
+	const postTypes = [...postTypeCounts.entries()].filter(([type]) => !isInternalPostType(type)).map(([name, count]) => {
+		const suggestedCollection = mapPostTypeToCollection(name);
+		const existingCollection = existingCollections.get(suggestedCollection);
+		const requiredFields = [...BASE_REQUIRED_FIELDS];
+		if (postTypesWithThumbnails.has(name)) requiredFields.push(FEATURED_IMAGE_FIELD);
+		return {
+			name,
+			count,
+			suggestedCollection,
+			requiredFields,
+			schemaStatus: checkSchemaCompatibility(requiredFields, existingCollection)
+		};
+	}).toSorted((a, b) => b.count - a.count);
+	const attachmentItems = wxr.attachments.map((att) => {
+		const filename = att.url ? getFilenameFromUrl(att.url) : void 0;
+		const mimeType = filename ? guessMimeType(filename) : void 0;
+		return {
+			id: att.id,
+			title: att.title,
+			url: att.url,
+			filename,
+			mimeType
+		};
+	});
+	const navMenus = wxr.navMenus.map((menu) => ({
+		name: menu.name,
+		label: menu.label,
+		itemCount: menu.items.length
+	}));
+	const taxonomyMap = /* @__PURE__ */ new Map();
+	for (const term of wxr.terms) {
+		if (term.taxonomy === "category" || term.taxonomy === "post_tag" || term.taxonomy === "nav_menu") continue;
+		const existing = taxonomyMap.get(term.taxonomy);
+		if (existing) {
+			existing.count++;
+			if (existing.samples.length < 3) existing.samples.push(term.name);
+		} else taxonomyMap.set(term.taxonomy, {
+			count: 1,
+			samples: [term.name]
+		});
+	}
+	const customTaxonomies = Array.from(taxonomyMap.entries(), ([slug, info]) => ({
+		slug,
+		termCount: info.count,
+		sampleTerms: info.samples
+	})).toSorted((a, b) => b.termCount - a.termCount);
+	const reusableBlocks = wxr.posts.filter((post) => post.postType === "wp_block").map((post) => ({
+		id: post.id || 0,
+		title: post.title || "Untitled Block",
+		slug: post.postName || slugify(post.title || `block-${post.id || Date.now()}`)
+	}));
+	return {
+		sourceId: "wxr",
+		site: {
+			title: wxr.site.title || "WordPress Site",
+			url: wxr.site.link || ""
+		},
+		postTypes,
+		attachments: {
+			count: wxr.attachments.length,
+			items: attachmentItems
+		},
+		categories: wxr.categories.length,
+		tags: wxr.tags.length,
+		authors: wxr.authors.map((a) => ({
+			id: a.id,
+			login: a.login,
+			email: a.email,
+			displayName: a.displayName || a.login || "Unknown",
+			postCount: a.login ? authorPostCounts.get(a.login) || 0 : 0
+		})),
+		navMenus: navMenus.length > 0 ? navMenus : void 0,
+		customTaxonomies: customTaxonomies.length > 0 ? customTaxonomies : void 0,
+		reusableBlocks: reusableBlocks.length > 0 ? reusableBlocks : void 0,
+		customFields
+	};
+}
+/**
+* Convert a WXR post to a normalized item
+*/
+function wxrPostToNormalizedItem(post, attachmentMap, siteUrl = "") {
+	const content = post.content ? gutenbergToPortableText(post.content) : [];
+	if (siteUrl) relativizeContentLinks(content, siteUrl);
+	const thumbnailId = post.meta.get("_thumbnail_id");
+	const featuredImage = thumbnailId ? attachmentMap.get(String(thumbnailId)) : void 0;
+	let customTaxonomies;
+	if (post.customTaxonomies && post.customTaxonomies.size > 0) {
+		const filtered = Object.fromEntries([...post.customTaxonomies].filter(([taxonomy]) => taxonomy !== "language"));
+		if (Object.keys(filtered).length > 0) customTaxonomies = filtered;
+	}
+	return {
+		sourceId: post.id || 0,
+		postType: post.postType || "post",
+		status: mapWpStatus(post.status),
+		slug: post.postName || slugify(post.title || `post-${post.id || Date.now()}`),
+		title: post.title || "Untitled",
+		content,
+		excerpt: post.excerpt,
+		date: parseWxrDate(post.postDateGmt, post.pubDate, post.postDate) ?? /* @__PURE__ */ new Date(),
+		modified: parseWxrDate(post.postModifiedGmt, void 0, post.postModified),
+		author: post.creator,
+		categories: post.categories,
+		tags: post.tags,
+		meta: Object.fromEntries(post.meta),
+		featuredImage,
+		parentId: post.postParent && post.postParent !== 0 ? post.postParent : void 0,
+		menuOrder: post.menuOrder,
+		customTaxonomies,
+		locale: post.locale,
+		translationGroup: post.translationGroup
+	};
+}
+/**
+* WordPress uses "0000-00-00 00:00:00" as a sentinel for missing GMT dates
+* (e.g. unpublished drafts). This must be treated as absent.
+*/
+const WXR_ZERO_DATE = "0000-00-00 00:00:00";
+/**
+* Parse a WXR date with the correct fallback chain:
+* 1. GMT date (always UTC, most reliable)
+* 2. pubDate (RFC 2822, includes timezone offset)
+* 3. Site-local date (MySQL datetime without timezone, imprecise but best available)
+*
+* Returns undefined when none of the inputs yield a valid date.
+* Callers that need a guaranteed Date should use `?? new Date()`.
+*/
+function parseWxrDate(gmtDate, pubDate, localDate) {
+	if (gmtDate && gmtDate !== WXR_ZERO_DATE) return /* @__PURE__ */ new Date(gmtDate.replace(" ", "T") + "Z");
+	if (pubDate) {
+		const d = new Date(pubDate);
+		if (!isNaN(d.getTime())) return d;
+	}
+	if (localDate) {
+		const d = new Date(localDate.replace(" ", "T"));
+		if (!isNaN(d.getTime())) return d;
+	}
+}
+
+//#endregion
+//#region src/import/wxr-taxonomies.ts
+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()
+	} };
+}
+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((collection) => typeof collection === "string");
+	} catch {}
+	return [];
+}
+async function findTaxonomyDef(db, name, locale) {
+	const chain = resolveLocaleChain(locale);
+	if (chain.length === 0) {
+		const row = await db.selectFrom("_dineway_taxonomy_defs").selectAll().where("name", "=", name).orderBy("locale", "asc").executeTakeFirst();
+		return row ? {
+			id: row.id,
+			collections: parseDefCollections(row.collections)
+		} : null;
+	}
+	for (const tryLocale of chain) {
+		const row = await db.selectFrom("_dineway_taxonomy_defs").selectAll().where("name", "=", name).where("locale", "=", tryLocale).executeTakeFirst();
+		if (row) return {
+			id: row.id,
+			collections: parseDefCollections(row.collections)
+		};
+	}
+	return null;
+}
+async function ensureTerm(repo, state, taxonomyName, slug, label, description, locale) {
+	const cached = state.plan.termIdByNameAndSlug.get(taxonomyName)?.get(slug);
+	if (cached) return cached;
+	const existing = await repo.findBySlug(taxonomyName, slug, locale);
+	if (existing) {
+		bump(state.plan.termsReused, taxonomyName);
+		rememberTerm(state, taxonomyName, slug, existing.id);
+		return existing.id;
+	}
+	const translationOf = (await repo.findBySlug(taxonomyName, slug))?.id;
+	const created = await repo.create({
+		name: taxonomyName,
+		slug,
+		label,
+		data: description ? { description } : void 0,
+		locale,
+		translationOf
+	});
+	bump(state.plan.termsCreated, taxonomyName);
+	rememberTerm(state, taxonomyName, slug, created.id);
+	return created.id;
+}
+function labelFor(post, taxonomy, slug) {
+	const key = `${taxonomy}\u0000${slug}`;
+	return post.taxonomyLabels?.get(key) ?? slug;
+}
+async function preImportWxrTaxonomies(db, posts, categories, tags, terms, locale) {
+	const state = makeState();
+	const repo = new TaxonomyRepository(db);
+	const defCache = /* @__PURE__ */ new Map();
+	const lookupDef = async (name) => {
+		if (defCache.has(name)) return defCache.get(name) ?? null;
+		const def = await findTaxonomyDef(db, name, locale);
+		defCache.set(name, def);
+		if (def) state.plan.collectionsByTaxonomy.set(name, new Set(def.collections));
+		return def;
+	};
+	const categoryDef = await lookupDef("category");
+	if (categoryDef) for (const category of categories) {
+		const slug = category.nicename;
+		const label = category.name;
+		if (!slug || !label) continue;
+		await ensureTerm(repo, state, "category", slug, label, category.description, locale);
+	}
+	else if (categories.length > 0) state.plan.missingTaxonomies.push("category");
+	const tagDef = await lookupDef("tag");
+	if (tagDef) for (const tag of tags) {
+		const slug = tag.slug;
+		const label = tag.name;
+		if (!slug || !label) continue;
+		await ensureTerm(repo, state, "tag", slug, label, tag.description, locale);
+	}
+	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;
+		}
+		await ensureTerm(repo, state, taxonomyName, term.slug, term.name, term.description, locale);
+	}
+	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;
+			await ensureTerm(repo, state, "category", slug, labelFor(post, "category", slug), void 0, locale);
+		}
+		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;
+			await ensureTerm(repo, state, "tag", slug, labelFor(post, "tag", slug), void 0, locale);
+		}
+		if (!post.customTaxonomies) continue;
+		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;
+				await ensureTerm(repo, state, taxonomyName, slug, labelFor(post, taxonomyName, slug), void 0, locale);
+			}
+		}
+	}
+	invalidateTermCache();
+	return state.plan;
+}
+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;
+}
+async function attachPostTaxonomies(db, collection, entryId, post, plan) {
+	const repo = new TaxonomyRepository(db);
+	const resolved = resolvePostTermAssignments(collection, post, plan);
+	let attached = 0;
+	for (const [, termIds] of resolved) for (const termId of termIds) if (await attachToEntryCountingInserts(db, repo, plan, collection, entryId, termId)) attached++;
+	return attached;
+}
+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;
+}
+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;
+}
+async function attachToEntryCountingInserts(db, repo, plan, collection, entryId, termId) {
+	const group = await termTranslationGroup(repo, plan, termId);
+	if (!group) return false;
+	if (await db.selectFrom("content_taxonomies").select("collection").where("collection", "=", collection).where("entry_id", "=", entryId).where("taxonomy_id", "=", group).executeTakeFirst()) return false;
+	await repo.attachToEntry(collection, entryId, termId);
+	return true;
+}
+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 canonicalGroup = await termTranslationGroup(repo, plan, canonicalTermId);
+		if (!canonicalGroup) continue;
+		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 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. 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 });
+			}
+		}
+	}
+}
+
+//#endregion
+//#region src/import/sources/wordpress-rest.ts
+/**
+* WordPress REST API probe
+*
+* Probes self-hosted WordPress sites to detect capabilities.
+* This source is probe-only - it tells users what's available
+* and suggests next steps (usually: upload WXR file).
+*/
+const TRAILING_SLASHES = /\/+$/;
+const WP_JSON_SUFFIX = /\/wp-json\/?$/;
+const wordpressRestSource = {
+	id: "wordpress-rest",
+	name: "WordPress Site",
+	description: "Connect to a self-hosted WordPress site",
+	icon: "globe",
+	requiresFile: false,
+	canProbe: true,
+	async probe(url) {
+		try {
+			const siteUrl = normalizeUrl(url);
+			validateExternalUrl(siteUrl);
+			const response = await ssrfSafeFetch(`${siteUrl}/wp-json/`, {
+				headers: { Accept: "application/json" },
+				signal: AbortSignal.timeout(1e4)
+			});
+			if (!response.ok) {
+				if (!(await ssrfSafeFetch(`${siteUrl}/?rest_route=/`, {
+					headers: { Accept: "application/json" },
+					signal: AbortSignal.timeout(1e4)
+				})).ok) return null;
+			}
+			const data = await response.json();
+			if (!data.namespaces?.includes("wp/v2")) return null;
+			const preview = await getPublicContentCounts(siteUrl);
+			const hasAppPasswords = !!data.authentication?.["application-passwords"];
+			return {
+				sourceId: "wordpress-rest",
+				confidence: "definite",
+				detected: {
+					platform: "wordpress",
+					siteTitle: data.name,
+					siteUrl: data.url || data.home || siteUrl
+				},
+				capabilities: {
+					publicContent: true,
+					privateContent: false,
+					customPostTypes: false,
+					allMeta: false,
+					mediaStream: true
+				},
+				auth: hasAppPasswords ? {
+					type: "password",
+					instructions: "To import drafts and private content, create an Application Password in WordPress → Users → Your Profile → Application Passwords"
+				} : void 0,
+				preview,
+				suggestedAction: {
+					type: "upload",
+					instructions: "For a complete import including drafts, custom post types, and all metadata, export your content from WordPress (Tools → Export) and upload the file here."
+				}
+			};
+		} catch {
+			return null;
+		}
+	},
+	async analyze(_input, _context) {
+		throw new Error("Direct REST API import not implemented. Please upload a WXR export file.");
+	},
+	async *fetchContent(_input, _options) {
+		throw new Error("Direct REST API import not implemented. Please upload a WXR export file.");
+	}
+};
+/**
+* Normalize a URL for API requests
+*/
+function normalizeUrl(url) {
+	let normalized = url.trim();
+	if (!normalized.startsWith("http")) normalized = `https://${normalized}`;
+	normalized = normalized.replace(TRAILING_SLASHES, "");
+	normalized = normalized.replace(WP_JSON_SUFFIX, "");
+	return normalized;
+}
+/**
+* Get public content counts from REST API
+*/
+async function getPublicContentCounts(siteUrl) {
+	const result = {};
+	try {
+		const [postsRes, pagesRes, mediaRes] = await Promise.allSettled([
+			ssrfSafeFetch(`${siteUrl}/wp-json/wp/v2/posts?per_page=1`, { signal: AbortSignal.timeout(5e3) }),
+			ssrfSafeFetch(`${siteUrl}/wp-json/wp/v2/pages?per_page=1`, { signal: AbortSignal.timeout(5e3) }),
+			ssrfSafeFetch(`${siteUrl}/wp-json/wp/v2/media?per_page=1`, { signal: AbortSignal.timeout(5e3) })
+		]);
+		if (postsRes.status === "fulfilled" && postsRes.value.ok) {
+			const total = postsRes.value.headers.get("X-WP-Total");
+			if (total) result.posts = parseInt(total, 10);
+		}
+		if (pagesRes.status === "fulfilled" && pagesRes.value.ok) {
+			const total = pagesRes.value.headers.get("X-WP-Total");
+			if (total) result.pages = parseInt(total, 10);
+		}
+		if (mediaRes.status === "fulfilled" && mediaRes.value.ok) {
+			const total = mediaRes.value.headers.get("X-WP-Total");
+			if (total) result.media = parseInt(total, 10);
+		}
+	} catch {}
+	return result;
+}
+
+//#endregion
+//#region src/import/sources/wordpress-plugin.ts
+/**
+* WordPress Plugin (Dineway Exporter) import source
+*
+* Connects to self-hosted WordPress sites running the Dineway Exporter plugin.
+* Provides full access to all content including drafts, custom post types, and ACF fields.
+*/
+const LEADING_SLASHES = /^\/+/;
+const TRAILING_SLASH = /\/$/;
+const FIELD_KEY_SEPARATORS = /[_-]+/;
+const CORE_TAXONOMY_NAMES = new Set([
+	"category",
+	"categories",
+	"post_tag",
+	"tags"
+]);
+const VALID_INFERRED_TYPES = new Set([
+	"string",
+	"text",
+	"number",
+	"integer",
+	"boolean",
+	"datetime",
+	"json",
+	"reference"
+]);
+const wordpressPluginSource = {
+	id: "wordpress-plugin",
+	name: "WordPress (Dineway Exporter)",
+	description: "Import from WordPress sites with the Dineway Exporter plugin installed",
+	icon: "plug",
+	requiresFile: false,
+	canProbe: true,
+	async probe(url) {
+		try {
+			const siteUrl = normalizeUrl$1(url);
+			validateExternalUrl(siteUrl);
+			const response = await fetchPluginApi(siteUrl, "probe", {}, { Accept: "application/json" }, 1e4);
+			if (!response.ok) return null;
+			const data = await response.json();
+			if (!data.dineway_exporter) return null;
+			return {
+				sourceId: "wordpress-plugin",
+				confidence: "definite",
+				detected: {
+					platform: "wordpress",
+					version: data.wordpress_version,
+					siteTitle: data.site.title,
+					siteUrl: data.site.url
+				},
+				capabilities: {
+					publicContent: true,
+					privateContent: true,
+					customPostTypes: true,
+					allMeta: true,
+					mediaStream: true
+				},
+				auth: data.capabilities.application_passwords ? {
+					type: "password",
+					instructions: data.auth_instructions.instructions
+				} : void 0,
+				preview: {
+					posts: data.post_types.find((p) => p.name === "post")?.count,
+					pages: data.post_types.find((p) => p.name === "page")?.count,
+					media: data.media_count
+				},
+				suggestedAction: { type: "proceed" },
+				i18n: pluginI18nToDetection(data.i18n)
+			};
+		} catch {
+			return null;
+		}
+	},
+	async analyze(input, context) {
+		const { siteUrl, headers } = getRequestConfig(input);
+		const response = await fetchPluginApi(siteUrl, "analyze", {}, headers, 3e4);
+		if (!response.ok) {
+			const error = await response.json().catch(() => ({}));
+			throw new Error(error.message || `Failed to analyze site: ${response.statusText}`);
+		}
+		const data = await response.json();
+		const existingCollections = context.getExistingCollections ? await context.getExistingCollections() : /* @__PURE__ */ new Map();
+		const postTypes = data.post_types.filter((pt) => pt.total > 0).map((pt) => {
+			const suggestedCollection = mapPostTypeToCollection(pt.name);
+			const existingCollection = existingCollections.get(suggestedCollection);
+			const requiredFields = pt.supports && "thumbnail" in pt.supports ? [...BASE_REQUIRED_FIELDS, FEATURED_IMAGE_FIELD] : [...BASE_REQUIRED_FIELDS];
+			const knownSlugs = new Set(requiredFields.map((field) => field.slug));
+			for (const customField of pt.custom_fields ?? []) {
+				if (isPluginBookkeepingMeta(customField.key)) continue;
+				const slug = sanitizeFieldSlug(customField.key);
+				if (knownSlugs.has(slug)) continue;
+				knownSlugs.add(slug);
+				requiredFields.push({
+					slug,
+					label: fieldLabelFromKey(customField.key),
+					type: mapInferredFieldType(customField.inferred_type),
+					required: false
+				});
+			}
+			return {
+				name: pt.name,
+				count: pt.total,
+				suggestedCollection,
+				requiredFields,
+				schemaStatus: checkSchemaCompatibility(requiredFields, existingCollection)
+			};
+		});
+		const attachments = [];
+		if (data.attachments.count > 0) try {
+			let page = 1;
+			let totalPages = 1;
+			while (page <= totalPages) {
+				const mediaResponse = await fetchPluginApi(siteUrl, "media", {
+					page,
+					per_page: 500
+				}, headers, 3e4);
+				if (!mediaResponse.ok) break;
+				const mediaData = await mediaResponse.json();
+				totalPages = Math.max(1, mediaData.pages || 1);
+				for (const item of mediaData.items) attachments.push({
+					id: item.id,
+					url: item.url,
+					filename: item.filename,
+					mimeType: item.mime_type,
+					title: item.title,
+					alt: item.alt,
+					caption: item.caption,
+					width: item.width,
+					height: item.height
+				});
+				page++;
+			}
+		} catch (e) {
+			console.warn("Failed to fetch media list:", e);
+		}
+		const categoryTaxonomy = data.taxonomies.find((t) => t.name === "category");
+		const tagTaxonomy = data.taxonomies.find((t) => t.name === "post_tag");
+		return {
+			sourceId: "wordpress-plugin",
+			site: {
+				title: data.site.title,
+				url: data.site.url
+			},
+			postTypes,
+			attachments: {
+				count: data.attachments.count,
+				items: attachments
+			},
+			categories: categoryTaxonomy?.term_count ?? 0,
+			tags: tagTaxonomy?.term_count ?? 0,
+			authors: data.authors.map((a) => ({
+				id: a.id,
+				login: a.login,
+				email: a.email,
+				displayName: a.display_name,
+				postCount: a.post_count
+			})),
+			i18n: pluginI18nToDetection(data.i18n)
+		};
+	},
+	async *fetchContent(input, options) {
+		const { siteUrl, headers } = getRequestConfig(input);
+		for (const postType of options.postTypes) {
+			let page = 1;
+			let totalPages = 1;
+			let yielded = 0;
+			while (page <= totalPages) {
+				const status = options.includeDrafts ? "any" : "publish";
+				const response = await fetchPluginApi(siteUrl, "content", {
+					page,
+					per_page: 100,
+					post_type: postType,
+					status
+				}, headers, 6e4);
+				if (!response.ok) throw new Error(`Failed to fetch ${postType}: ${response.statusText}`);
+				const data = await response.json();
+				totalPages = data.pages;
+				for (const post of data.items) {
+					yield pluginPostToNormalizedItem(post, siteUrl);
+					yielded++;
+					if (options.limit && yielded >= options.limit) return;
+				}
+				page++;
+			}
+		}
+	},
+	async fetchMedia(url, _input) {
+		validateExternalUrl(url);
+		const response = await ssrfSafeFetch(url);
+		if (!response.ok) throw new Error(`Failed to fetch media: ${response.statusText}`);
+		return response.blob();
+	}
+};
+/**
+* Convert plugin i18n info to the shared I18nDetection type.
+* Returns undefined when no multilingual plugin is detected.
+*/
+function pluginI18nToDetection(i18n) {
+	if (!i18n) return void 0;
+	return {
+		plugin: i18n.plugin,
+		defaultLocale: i18n.default_locale,
+		locales: i18n.locales
+	};
+}
+function mapInferredFieldType(inferredType) {
+	return VALID_INFERRED_TYPES.has(inferredType) ? inferredType : "string";
+}
+function fieldLabelFromKey(key) {
+	return key.split(FIELD_KEY_SEPARATORS).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function pluginApiUrl(siteUrl, endpoint, params = {}, restRoute = false) {
+	const cleanEndpoint = endpoint.replace(LEADING_SLASHES, "");
+	const url = restRoute ? new URL(`${siteUrl.replace(TRAILING_SLASH, "")}/`) : new URL(`${siteUrl.replace(TRAILING_SLASH, "")}/wp-json/dineway/v1/${cleanEndpoint}`);
+	if (restRoute) url.searchParams.set("rest_route", `/dineway/v1/${cleanEndpoint}`);
+	for (const [key, value] of Object.entries(params)) if (value !== void 0) url.searchParams.set(key, String(value));
+	return url.toString();
+}
+async function fetchPluginApi(siteUrl, endpoint, params, headers, timeoutMs) {
+	try {
+		const response = await ssrfSafeFetch(pluginApiUrl(siteUrl, endpoint, params), {
+			headers,
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+		if (response.status !== 404) return response;
+	} catch {}
+	return ssrfSafeFetch(pluginApiUrl(siteUrl, endpoint, params, true), {
+		headers,
+		signal: AbortSignal.timeout(timeoutMs)
+	});
+}
+/**
+* Get request configuration from input
+*/
+function getRequestConfig(input) {
+	if (input.type === "url") {
+		const siteUrl = normalizeUrl$1(input.url);
+		validateExternalUrl(siteUrl);
+		const headers = { Accept: "application/json" };
+		if (input.token) headers["Authorization"] = `Basic ${input.token}`;
+		return {
+			siteUrl,
+			headers
+		};
+	}
+	if (input.type === "oauth") {
+		const oauthSiteUrl = normalizeUrl$1(input.url);
+		validateExternalUrl(oauthSiteUrl);
+		return {
+			siteUrl: oauthSiteUrl,
+			headers: {
+				Accept: "application/json",
+				Authorization: `Bearer ${input.accessToken}`
+			}
+		};
+	}
+	throw new Error("WordPress plugin source requires URL or OAuth input");
+}
+/**
+* Convert plugin post to normalized item
+*/
+function pluginPostToNormalizedItem(post, siteUrl) {
+	const content = post.content ? gutenbergToPortableText(post.content) : [];
+	relativizeContentLinks(content, siteUrl);
+	const categories = post.taxonomies?.category?.map((c) => c.slug) ?? post.taxonomies?.categories?.map((c) => c.slug) ?? [];
+	const tags = post.taxonomies?.post_tag?.map((t) => t.slug) ?? post.taxonomies?.tags?.map((t) => t.slug) ?? [];
+	const customTaxonomies = {};
+	for (const [name, terms] of Object.entries(post.taxonomies ?? {})) {
+		if (CORE_TAXONOMY_NAMES.has(name)) continue;
+		if (terms.length > 0) customTaxonomies[name] = terms.map((term) => term.slug);
+	}
+	const meta = { ...post.meta };
+	if (post.acf) meta._acf = post.acf;
+	if (post.yoast) meta._yoast = post.yoast;
+	if (post.rankmath) meta._rankmath = post.rankmath;
+	return {
+		sourceId: post.id,
+		postType: post.post_type,
+		status: mapWpStatus(post.status),
+		slug: post.slug,
+		title: post.title,
+		content,
+		excerpt: post.excerpt || void 0,
+		date: new Date(post.date_gmt || post.date),
+		modified: post.modified_gmt ? new Date(post.modified_gmt) : new Date(post.modified),
+		author: post.author?.login,
+		categories,
+		tags,
+		customTaxonomies: Object.keys(customTaxonomies).length > 0 ? customTaxonomies : void 0,
+		meta,
+		featuredImage: post.featured_image?.url,
+		locale: post.locale,
+		translationGroup: post.translation_group
+	};
+}
+/**
+* Fetch navigation menus from plugin API.
+* Returns an empty array when the endpoint doesn't exist on older plugins.
+*/
+async function fetchPluginMenus(siteUrl, authToken) {
+	const normalizedSiteUrl = normalizeUrl$1(siteUrl);
+	validateExternalUrl(normalizedSiteUrl);
+	const response = await fetchPluginApi(normalizedSiteUrl, "menus", {}, {
+		Accept: "application/json",
+		Authorization: `Basic ${authToken}`
+	}, 3e4);
+	if (response.status === 404) return [];
+	if (!response.ok) throw new Error(`Failed to fetch menus: ${response.statusText}`);
+	return response.json();
+}
+/**
+* Fetch site options from plugin API.
+*/
+async function fetchPluginOptions(siteUrl, authToken) {
+	const normalizedSiteUrl = normalizeUrl$1(siteUrl);
+	validateExternalUrl(normalizedSiteUrl);
+	const response = await fetchPluginApi(normalizedSiteUrl, "options", {}, {
+		Accept: "application/json",
+		Authorization: `Basic ${authToken}`
+	}, 3e4);
+	if (!response.ok) throw new Error(`Failed to fetch options: ${response.statusText}`);
+	return response.json();
+}
+/**
+* Fetch all comments from plugin API, paginating through every page.
+* Returns an empty array when the endpoint doesn't exist on older plugins.
+*/
+async function fetchPluginComments(siteUrl, authToken) {
+	const normalizedSiteUrl = normalizeUrl$1(siteUrl);
+	validateExternalUrl(normalizedSiteUrl);
+	const comments = [];
+	let page = 1;
+	let totalPages = 1;
+	while (page <= totalPages) {
+		const response = await fetchPluginApi(normalizedSiteUrl, "comments", {
+			page,
+			per_page: 500
+		}, {
+			Accept: "application/json",
+			Authorization: `Basic ${authToken}`
+		}, 3e4);
+		if (response.status === 404) return [];
+		if (!response.ok) throw new Error(`Failed to fetch comments: ${response.statusText}`);
+		const data = await response.json();
+		totalPages = Math.max(1, data.pages || 1);
+		comments.push(...data.items);
+		page++;
+	}
+	return comments;
+}
+
+//#endregion
+//#region src/import/index.ts
+registerSource(wordpressPluginSource);
+registerSource(wordpressRestSource);
+registerSource(wxrSource);
+
+//#endregion
+export { importMenusFromPlugin as C, importCommentsFromPlugin as S, probeUrl as _, attachPostTaxonomies as a, parseSiteSettingsFromPlugin as b, preImportWxrTaxonomies as c, wxrSource as d, clearSources as f, getUrlSources as g, getSource as h, wordpressRestSource as i, setPostTermAssignmentsReplacing as l, getFileSources as m, fetchPluginMenus as n, isWxrTaxonomyConflictError as o, getAllSources as p, fetchPluginOptions as r, mirrorTermsToLocales as s, fetchPluginComments as t, parseWxrDate as u, registerSource as v, importReusableBlocksAsSections as x, importSiteSettings as y };