emdash 0.27.0 → 0.28.0

package/dist/{import-Bb1T9WJS.mjs → import-fYLf14Co.mjs}

@@ -1,6 +1,9 @@
+import { s as invalidateCommentObjectCache } from "./object-cache-Bok5j2ae.mjs";
 import { n as slugify } from "./slugify-Cce3dTdg.mjs";
-import { a as validateExternalUrl, n as resolveAndValidateExternalUrl, r as ssrfSafeFetch } from "./ssrf-BRKb343l.mjs";
-import { a as getFilenameFromUrl, c as isInternalMetaKey, d as mapPostTypeToCollection, f as mapWpStatus, i as checkSchemaCompatibility, l as isInternalPostType, n as FEATURED_IMAGE_FIELD, o as guessMimeType, p as normalizeUrl$1, r as buildAttachmentMap, s as inferMetaType, t as BASE_REQUIRED_FIELDS, u as mapMetaKeyToField } from "./utils-B7A57fm9.mjs";
+import { t as OptionsRepository } from "./options-DTTML-Tx.mjs";
+import { o as invalidateSiteSettingsCache } from "./settings-zhmdKyJQ.mjs";
+import { a as validateExternalUrl, n as resolveAndValidateExternalUrl, r as ssrfSafeFetch } from "./ssrf-1g7usGBg.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-BJXElxdw.mjs";
 import { ulid } from "ulidx";
 import sax from "sax";
 import { gutenbergToPortableText } from "@emdash-cms/gutenberg-to-portable-text";
@@ -844,6 +847,135 @@ function buildNavMenus(navMenuItemPosts, menuTermsBySlug) {
 	return menus;
 }
 
+//#endregion
+//#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 EmDash 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("_emdash_menus").select("id").where("name", "=", menu.name).executeTakeFirst();
+		if (existing) {
+			result.menuIdMap.set(menu.name, existing.id);
+			continue;
+		}
+		const menuId = ulid();
+		await db.insertInto("_emdash_menus").values({
+			id: menuId,
+			name: menu.name,
+			label: menu.label
+		}).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("_emdash_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
+		}).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("_emdash_menu_items").set({ parent_id: parentId }).where("id", "=", itemId).execute();
+	}
+	return count;
+}
+/**
+* Map Plugin menu item to EmDash 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 EmDash collection name
+*/
+function mapObjectToCollection(objectType) {
+	if (!objectType) return "posts";
+	return {
+		post: "posts",
+		page: "pages",
+		product: "products",
+		portfolio: "portfolio"
+	}[objectType] || objectType;
+}
+
 //#endregion
 //#region src/import/sections.ts
 /**
@@ -893,6 +1025,166 @@ async function importReusableBlocksAsSections(posts, db) {
 	return result;
 }
 
+//#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, and
+* timestamp is not created twice.
+*
+* @param comments - Comments from the plugin API (all pages, flat)
+* @param db - Database connection
+* @param contentIdMap - WP post ID -> EmDash content ID
+* @param collectionMap - WP post ID -> EmDash collection slug
+* @param rootIds - Optional pre-seeded WP-comment-ID -> EmDash-root-ID map.
+*   The chunked import passes the map accumulated from earlier pages so a
+*   reply in page N can thread onto a parent imported in page N-1; the
+*   function adds this page's entries to it.
+*/
+async function importCommentsFromPlugin(comments, db, contentIdMap, collectionMap, rootIds) {
+	const result = {
+		imported: 0,
+		skipped: 0,
+		errors: []
+	};
+	const commentIdMap = /* @__PURE__ */ new Map();
+	const rootIdMap = rootIds ?? /* @__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("_emdash_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) {
+				commentIdMap.set(comment.id, existing.id);
+				rootIdMap.set(comment.id, parentId ?? existing.id);
+				result.skipped++;
+				continue;
+			}
+			const id = ulid();
+			await db.insertInto("_emdash_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();
+			commentIdMap.set(comment.id, id);
+			rootIdMap.set(comment.id, parentId ?? id);
+			result.imported++;
+		} catch (error) {
+			result.errors.push({
+				comment: label,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	if (result.imported > 0) invalidateCommentObjectCache();
+	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 EmDash 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 EmDash media IDs.
+*
+* @param settings - Site settings analysis
+* @param db - Database connection
+* @param overwrite - Whether to overwrite existing settings (a fresh
+*   site's seed already sets title/tagline, so migrations pass true)
+* @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
 /**
@@ -1004,7 +1296,7 @@ const wxrSource = {
 			if (!options.postTypes.includes(postType)) continue;
 			if (isInternalPostType(postType)) continue;
 			if (!options.includeDrafts && post.status !== "publish") continue;
-			yield wxrPostToNormalizedItem(post, attachmentMap);
+			yield wxrPostToNormalizedItem(post, attachmentMap, wxr.site.link || "");
 			count++;
 			if (options.limit && count >= options.limit) break;
 		}
@@ -1123,8 +1415,9 @@ function analyzeWxrData(wxr, existingCollections) {
 /**
 * Convert a WXR post to a normalized item
 */
-function wxrPostToNormalizedItem(post, attachmentMap) {
+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;
@@ -1297,6 +1590,44 @@ async function getPublicContentCounts(siteUrl) {
 * Connects to self-hosted WordPress sites running the EmDash Exporter plugin.
 * Provides full access to all content including drafts, custom post types, and ACF fields.
 */
+/**
+* Build the REST API URL for a plugin endpoint.
+*
+* `restRoute: false` uses the pretty form (`/wp-json/emdash/v1/...`),
+* `restRoute: true` uses the `?rest_route=` form that works on sites with
+* plain permalinks (where `/wp-json/` doesn't exist).
+*/
+function pluginApiUrl(siteUrl, path, params = {}, restRoute = false) {
+	if (restRoute) {
+		const url = new URL(siteUrl + "/");
+		url.searchParams.set("rest_route", `/emdash/v1/${path}`);
+		for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);
+		return url.toString();
+	}
+	const url = new URL(`${siteUrl}/wp-json/emdash/v1/${path}`);
+	for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);
+	return url.toString();
+}
+/**
+* Fetch a plugin API endpoint, falling back to the `?rest_route=` form when
+* the pretty `/wp-json/` route 404s or is unreachable. Sites with "Plain"
+* permalinks have no `/wp-json/` rewrite, so without this fallback they
+* always fail with a misleading 404.
+*/
+async function fetchPluginApi(siteUrl, path, params, headers, timeoutMs) {
+	let pretty = null;
+	try {
+		pretty = await ssrfSafeFetch(pluginApiUrl(siteUrl, path, params), {
+			headers,
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+	} catch {}
+	if (pretty && pretty.status !== 404) return pretty;
+	return ssrfSafeFetch(pluginApiUrl(siteUrl, path, params, true), {
+		headers,
+		signal: AbortSignal.timeout(timeoutMs)
+	});
+}
 const wordpressPluginSource = {
 	id: "wordpress-plugin",
 	name: "WordPress (EmDash Exporter)",
@@ -1308,10 +1639,7 @@ const wordpressPluginSource = {
 		try {
 			const siteUrl = normalizeUrl$1(url);
 			validateExternalUrl(siteUrl);
-			const response = await ssrfSafeFetch(`${siteUrl}/wp-json/emdash/v1/probe`, {
-				headers: { Accept: "application/json" },
-				signal: AbortSignal.timeout(1e4)
-			});
+			const response = await fetchPluginApi(siteUrl, "probe", {}, { Accept: "application/json" }, 1e4);
 			if (!response.ok) return null;
 			const data = await response.json();
 			if (!data.emdash_exporter) return null;
@@ -1349,10 +1677,7 @@ const wordpressPluginSource = {
 	},
 	async analyze(input, context) {
 		const { siteUrl, headers } = getRequestConfig(input);
-		const response = await ssrfSafeFetch(`${siteUrl}/wp-json/emdash/v1/analyze`, {
-			headers,
-			signal: AbortSignal.timeout(3e4)
-		});
+		const response = await fetchPluginApi(siteUrl, "analyze", {}, headers, 3e4);
 		if (!response.ok) {
 			const body = await response.json().catch(() => void 0);
 			const message = typeof body === "object" && body !== null && "message" in body && typeof body.message === "string" ? body.message : "";
@@ -1364,6 +1689,19 @@ const wordpressPluginSource = {
 			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((f) => f.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,
@@ -1374,12 +1712,16 @@ const wordpressPluginSource = {
 		});
 		const attachments = [];
 		if (data.attachments.count > 0) try {
-			const mediaResponse = await ssrfSafeFetch(`${siteUrl}/wp-json/emdash/v1/media?per_page=500`, {
-				headers,
-				signal: AbortSignal.timeout(3e4)
-			});
-			if (mediaResponse.ok) {
+			let page = 1;
+			let totalPages = 1;
+			while (page <= totalPages) {
+				const mediaResponse = await fetchPluginApi(siteUrl, "media", {
+					per_page: "500",
+					page: String(page)
+				}, headers, 3e4);
+				if (!mediaResponse.ok) break;
 				const mediaData = await mediaResponse.json();
+				totalPages = mediaData.pages;
 				for (const item of mediaData.items) attachments.push({
 					id: item.id,
 					url: item.url,
@@ -1391,6 +1733,7 @@ const wordpressPluginSource = {
 					width: item.width,
 					height: item.height
 				});
+				page++;
 			}
 		} catch (e) {
 			console.warn("Failed to fetch media list:", e);
@@ -1427,15 +1770,17 @@ const wordpressPluginSource = {
 			let totalPages = 1;
 			let yielded = 0;
 			while (page <= totalPages) {
-				const response = await ssrfSafeFetch(`${siteUrl}/wp-json/emdash/v1/content?post_type=${postType}&status=${options.includeDrafts ? "any" : "publish"}&per_page=100&page=${page}`, {
-					headers,
-					signal: AbortSignal.timeout(6e4)
-				});
+				const response = await fetchPluginApi(siteUrl, "content", {
+					post_type: postType,
+					status: options.includeDrafts ? "any" : "publish",
+					per_page: "100",
+					page: String(page)
+				}, 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);
+					yield pluginPostToNormalizedItem(post, siteUrl);
 					yielded++;
 					if (options.limit && yielded >= options.limit) return;
 				}
@@ -1451,6 +1796,54 @@ const wordpressPluginSource = {
 	}
 };
 /**
+* Fetch a single page of content for one post type. This is the unit of
+* work for the chunked import: one Worker invocation imports one page,
+* keeping each request far below Cloudflare's CPU and subrequest limits
+* (see issue #475).
+*/
+async function fetchPluginContentPage(options) {
+	const { siteUrl, headers } = getRequestConfig({
+		type: "url",
+		url: options.siteUrl,
+		token: options.token
+	});
+	const response = await fetchPluginApi(siteUrl, "content", {
+		post_type: options.postType,
+		status: options.includeDrafts ? "any" : "publish",
+		per_page: String(options.perPage),
+		page: String(options.page)
+	}, headers, 6e4);
+	if (!response.ok) throw new Error(`Failed to fetch ${options.postType}: ${response.statusText}`);
+	const data = await response.json();
+	return {
+		items: data.items.map((post) => pluginPostToNormalizedItem(post, siteUrl)),
+		totalPages: data.pages
+	};
+}
+/** Plugin `inferred_type` values that are valid EmDash field types as-is */
+const VALID_INFERRED_TYPES = new Set([
+	"string",
+	"text",
+	"number",
+	"integer",
+	"boolean",
+	"datetime",
+	"json",
+	"reference"
+]);
+/**
+* Map the plugin's inferred custom-field type to an EmDash field type.
+* Unknown values fall back to string (always safe for TEXT storage).
+*/
+function mapInferredFieldType(inferredType) {
+	return VALID_INFERRED_TYPES.has(inferredType) ? inferredType : "string";
+}
+const FIELD_KEY_SEPARATORS = /[_-]+/;
+/** Derive a human label from a meta key: "event_start-date" -> "Event Start Date" */
+function fieldLabelFromKey(key) {
+	return key.split(FIELD_KEY_SEPARATORS).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+/**
 * Convert plugin i18n info to the shared I18nDetection type.
 * Returns undefined when no multilingual plugin is detected.
 */
@@ -1492,10 +1885,21 @@ function getRequestConfig(input) {
 /**
 * Convert plugin post to normalized item
 */
-function pluginPostToNormalizedItem(post) {
+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 ([
+			"category",
+			"categories",
+			"post_tag",
+			"tags"
+		].includes(name)) continue;
+		if (Array.isArray(terms) && terms.length > 0) customTaxonomies[name] = terms.map((t) => t.slug);
+	}
 	const meta = { ...post.meta };
 	if (post.acf) meta._acf = post.acf;
 	if (post.yoast) meta._yoast = post.yoast;
@@ -1513,12 +1917,97 @@ function pluginPostToNormalizedItem(post) {
 		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 taxonomies from plugin API
+*/
+async function fetchPluginTaxonomies(siteUrl, authToken) {
+	const normalizedSiteUrl = normalizeUrl$1(siteUrl);
+	validateExternalUrl(normalizedSiteUrl);
+	const response = await fetchPluginApi(normalizedSiteUrl, "taxonomies", {}, {
+		Accept: "application/json",
+		Authorization: `Basic ${authToken}`
+	}, 3e4);
+	if (!response.ok) throw new Error(`Failed to fetch taxonomies: ${response.statusText}`);
+	return response.json();
+}
+/**
+* Fetch navigation menus from plugin API (added in emdash-exporter 1.1.0).
+* Returns an empty array when the endpoint doesn't exist (older plugin).
+*/
+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 (title, tagline, logo, favicon, ...)
+*/
+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 a single page of comments from the plugin API (added in
+* emdash-exporter 1.2.0). The exporter orders by comment ID ascending, so
+* parents always appear before their children across pages. Returns
+* `totalPages: 0` when the endpoint doesn't exist (older plugin).
+*/
+async function fetchPluginCommentsPage(siteUrl, authToken, page) {
+	const normalizedSiteUrl = normalizeUrl$1(siteUrl);
+	validateExternalUrl(normalizedSiteUrl);
+	const response = await fetchPluginApi(normalizedSiteUrl, "comments", {
+		per_page: "500",
+		page: String(page)
+	}, {
+		Accept: "application/json",
+		Authorization: `Basic ${authToken}`
+	}, 3e4);
+	if (response.status === 404) return {
+		items: [],
+		totalPages: 0
+	};
+	if (!response.ok) throw new Error(`Failed to fetch comments: ${response.statusText}`);
+	const data = await response.json();
+	return {
+		items: data.items,
+		totalPages: data.pages
+	};
+}
+/**
+* Fetch all comments from plugin API, paginating through every page.
+* Returns an empty array when the endpoint doesn't exist (older plugin).
+*/
+async function fetchPluginComments(siteUrl, authToken) {
+	const comments = [];
+	let page = 1;
+	let totalPages = 1;
+	while (page <= totalPages) {
+		const result = await fetchPluginCommentsPage(siteUrl, authToken, page);
+		totalPages = result.totalPages;
+		comments.push(...result.items);
+		page++;
+	}
+	return comments;
+}
 
 //#endregion
 //#region src/import/index.ts
@@ -1527,5 +2016,5 @@ registerSource(wordpressRestSource);
 registerSource(wxrSource);
 
 //#endregion
-export { getAllSources as a, getUrlSources as c, importReusableBlocksAsSections as d, parseWxr as f, clearSources as i, probeUrl as l, parseWxrDate as n, getFileSources as o, parseWxrString as p, wxrSource as r, getSource as s, wordpressRestSource as t, registerSource as u };
-//# sourceMappingURL=import-Bb1T9WJS.mjs.map
+export { parseWxrString as C, parseWxr as S, importSiteSettings as _, fetchPluginOptions as a, importReusableBlocksAsSections as b, parseWxrDate as c, getAllSources as d, getFileSources as f, registerSource as g, probeUrl as h, fetchPluginMenus as i, wxrSource as l, getUrlSources as m, fetchPluginCommentsPage as n, fetchPluginTaxonomies as o, getSource as p, fetchPluginContentPage as r, wordpressRestSource as s, fetchPluginComments as t, clearSources as u, parseSiteSettingsFromPlugin as v, importMenusFromPlugin as x, importCommentsFromPlugin as y };
+//# sourceMappingURL=import-fYLf14Co.mjs.map