emdash 0.26.0 → 0.28.0

package/src/astro/routes/api/import/wordpress-plugin/execute.ts

@@ -7,26 +7,59 @@
  */
 
 import type { APIRoute } from "astro";
-import { ContentRepository, SchemaRegistry } from "emdash";
+import {
+	ContentRepository,
+	SchemaRegistry,
+	type WxrCategory,
+	type WxrPost,
+	type WxrTag,
+	type WxrTerm,
+} from "emdash";
+import type { z } from "zod";
 
 import { requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError } from "#api/error.js";
+import { handleTaxonomyCreate } from "#api/handlers/taxonomies.js";
 import { isParseError, parseBody } from "#api/parse.js";
 import { wpPluginExecuteBody } from "#api/schemas.js";
 import { BylineRepository } from "#db/repositories/byline.js";
+import { importCommentsFromPlugin } from "#import/comments.js";
 import { getSource } from "#import/index.js";
+import { importMenusFromPlugin } from "#import/menus.js";
+import { importSiteSettings, parseSiteSettingsFromPlugin } from "#import/settings.js";
+import {
+	fetchPluginComments,
+	fetchPluginCommentsPage,
+	fetchPluginContentPage,
+	fetchPluginMenus,
+	fetchPluginOptions,
+	fetchPluginTaxonomies,
+} from "#import/sources/wordpress-plugin.js";
 import { resolveAndValidateExternalUrl, SsrfError } from "#import/ssrf.js";
 import type { ImportConfig, ImportResult, NormalizedItem } from "#import/types.js";
-import { resolveImportByline } from "#import/utils.js";
+import { resolveImportByline, sanitizeFieldSlug } from "#import/utils.js";
+import {
+	attachPostTaxonomies,
+	loadTaxonomyPlanFromDb,
+	preImportWxrTaxonomies,
+	type TaxonomyImportPlan,
+} from "#import/wxr-taxonomies.js";
 import type { FieldType } from "#schema/types.js";
 import type { EmDashHandlers, EmDashManifest } from "#types";
 import { slugify } from "#utils/slugify.js";
 
+import { importMediaWithProgress } from "../wordpress/media.js";
+
 export const prerender = false;
 
 export interface WpPluginImportConfig extends ImportConfig {
 	/** Author mappings (WP author login -> EmDash user ID) */
 	authorMappings?: Record<string, string | null>;
+	/** Wizard toggles. Absent means enabled (older admins don't send them). */
+	importMenus?: boolean;
+	importSiteTitle?: boolean;
+	importLogo?: boolean;
+	importSeo?: boolean;
 }
 
 export interface WpPluginImportResponse {
@@ -35,6 +68,71 @@ export interface WpPluginImportResponse {
 	error?: { message: string };
 }
 
+// =============================================================================
+// Chunked mode (issue #475)
+//
+// A single-invocation import of a large site exceeds Cloudflare Worker
+// resource limits (CPU time, subrequests). In chunked mode the admin drives
+// the import as a loop of bounded requests: one WP content page per call,
+// then paginated comments, then a small finalize step (menus + site
+// identity). Cross-chunk state — the WP-ID -> EmDash-ID map, translation
+// groups, comment threading roots — is accumulated by the client and sent
+// back with each request, so the server stays stateless and an aborted
+// import simply re-runs (skipExisting rebuilds the map while skipping work).
+// =============================================================================
+
+/** Posts per content chunk. 50 posts ≈ a few hundred D1 ops per invocation. */
+const CONTENT_CHUNK_SIZE = 50;
+
+interface ChunkCursor {
+	postTypeIndex: number;
+	page: number;
+}
+
+/** Per-chunk response payload: partial result + state the client must carry. */
+interface ChunkResponse {
+	success: boolean;
+	result: ImportResult;
+	done: boolean;
+	cursor?: ChunkCursor;
+	chunk?: {
+		idMap?: Record<string, { id: string; collection: string }>;
+		translationGroups?: Record<string, string>;
+		commentRoots?: Record<string, string>;
+	};
+}
+
+function emptyImportResult(): ImportResult {
+	return { success: true, imported: 0, skipped: 0, errors: [], byCollection: {} };
+}
+
+function parseIdMap(idMap: Record<string, { id: string; collection: string }> | undefined): {
+	contentIdMap: Map<number, string>;
+	collectionByWpId: Map<number, string>;
+} {
+	const contentIdMap = new Map<number, string>();
+	const collectionByWpId = new Map<number, string>();
+	for (const [key, value] of Object.entries(idMap ?? {})) {
+		const wpId = Number(key);
+		if (!Number.isFinite(wpId)) continue;
+		contentIdMap.set(wpId, value.id);
+		collectionByWpId.set(wpId, value.collection);
+	}
+	return { contentIdMap, collectionByWpId };
+}
+
+function serializeIdMap(
+	contentIdMap: Map<number, string>,
+	collectionByWpId: Map<number, string>,
+): Record<string, { id: string; collection: string }> {
+	const out: Record<string, { id: string; collection: string }> = {};
+	for (const [wpId, id] of contentIdMap) {
+		const collection = collectionByWpId.get(wpId);
+		if (collection) out[String(wpId)] = { id, collection };
+	}
+	return out;
+}
+
 export const POST: APIRoute = async ({ request, locals }) => {
 	const { emdash, user } = locals;
 
@@ -81,8 +179,27 @@ export const POST: APIRoute = async ({ request, locals }) => {
 		console.log("[WP Plugin Import] Starting import for:", body.url);
 		console.log("[WP Plugin Import] Post types:", postTypes);
 
+		// Chunked mode: one bounded unit of work per invocation (issue #475).
+		if (body.phase) {
+			const chunk = await runImportPhase(emdash, body, config, postTypes, emdashManifest);
+			return apiSuccess(chunk);
+		}
+
+		// Pre-create taxonomy defs (for custom CPT taxonomies) and terms so
+		// per-post assignments can attach.
+		// Non-fatal: a site whose /taxonomies call fails still gets content.
+		let taxonomyPlan: TaxonomyImportPlan | undefined;
+		let taxonomyDefsCreated: string[] = [];
+		try {
+			const built = await buildTaxonomyPlan(emdash, body.url, body.token, config);
+			taxonomyPlan = built.plan;
+			taxonomyDefsCreated = built.defsCreated;
+		} catch (e) {
+			console.warn("[WP Plugin Import] Taxonomy pre-import failed:", e);
+		}
+
 		// Import content (including drafts since we have auth)
-		const result = await importContent(
+		const { result, contentIdMap, collectionByWpId } = await importContent(
 			source.fetchContent(
 				{ type: "url", url: body.url, token: body.token },
 				{ postTypes, includeDrafts: true },
@@ -90,8 +207,55 @@ export const POST: APIRoute = async ({ request, locals }) => {
 			config,
 			emdash,
 			emdashManifest,
+			taxonomyPlan,
 		);
 
+		// Import navigation menus, resolving item references through the
+		// WP-post-ID -> EmDash-ID map collected during the content pass.
+		if (config.importMenus !== false) {
+			await importMenusInto(result, emdash, body.url, body.token, contentIdMap);
+		}
+
+		// Import comments into EmDash's native comments table, preserving
+		// authors, dates, threading, and approval status.
+		// Non-fatal: older plugin versions have no /comments endpoint.
+		try {
+			const comments = await fetchPluginComments(body.url, body.token);
+			if (comments.length > 0) {
+				const commentsResult = await importCommentsFromPlugin(
+					comments,
+					emdash.db,
+					contentIdMap,
+					collectionByWpId,
+				);
+				result.comments = {
+					imported: commentsResult.imported,
+					skipped: commentsResult.skipped,
+				};
+				for (const commentError of commentsResult.errors) {
+					result.errors.push({
+						title: `Comment: ${commentError.comment}`,
+						error: commentError.error,
+					});
+				}
+			}
+		} catch (e) {
+			console.warn("[WP Plugin Import] Comment import failed:", e);
+		}
+
+		// Apply site identity (title, tagline, logo, favicon) from the source
+		// site's options, replacing the starter template's seed placeholders.
+		// Non-fatal: content is already imported at this point.
+		try {
+			result.siteSettings = await applySiteSettings(emdash, body.url, body.token, config);
+		} catch (e) {
+			console.warn("[WP Plugin Import] Site settings import failed:", e);
+		}
+
+		if (taxonomyDefsCreated.length > 0) {
+			result.taxonomiesCreated = taxonomyDefsCreated;
+		}
+
 		console.log("[WP Plugin Import] Import result:", JSON.stringify(result, null, 2));
 
 		return apiSuccess({
@@ -103,6 +267,213 @@ export const POST: APIRoute = async ({ request, locals }) => {
 	}
 };
 
+/**
+ * Import navigation menus into `result`, resolving item references through
+ * the WP-post-ID -> EmDash-ID map collected during the content pass.
+ * Non-fatal: older plugin versions have no /menus endpoint.
+ */
+async function importMenusInto(
+	result: ImportResult,
+	emdash: EmDashHandlers,
+	url: string,
+	token: string,
+	contentIdMap: Map<number, string>,
+): Promise<void> {
+	try {
+		const menus = await fetchPluginMenus(url, token);
+		if (menus.length > 0) {
+			const menuResult = await importMenusFromPlugin(menus, emdash.db, contentIdMap);
+			result.menus = {
+				created: menuResult.menusCreated,
+				items: menuResult.itemsCreated,
+			};
+			for (const menuError of menuResult.errors) {
+				result.errors.push({ title: `Menu: ${menuError.menu}`, error: menuError.error });
+			}
+		}
+	} catch (e) {
+		console.warn("[WP Plugin Import] Menu import failed:", e);
+	}
+}
+
+type ExecuteBody = z.infer<typeof wpPluginExecuteBody>;
+
+/** Dispatch one chunk of work for the requested phase. */
+async function runImportPhase(
+	emdash: EmDashHandlers,
+	body: ExecuteBody,
+	config: WpPluginImportConfig,
+	postTypes: string[],
+	manifest: EmDashManifest,
+): Promise<ChunkResponse> {
+	switch (body.phase) {
+		case "content":
+			return runContentChunk(emdash, body, config, postTypes, manifest);
+		case "comments":
+			return runCommentsChunk(emdash, body);
+		case "finalize":
+			return runFinalizePhase(emdash, body, config);
+		case undefined:
+			throw new Error("runImportPhase called without a phase");
+		default:
+			body.phase satisfies never;
+			throw new Error("Unknown import phase");
+	}
+}
+
+/**
+ * Import one page of one post type. The first chunk additionally runs the
+ * taxonomy setup (def + term creation); later chunks only reload the
+ * lookup maps from the database.
+ */
+async function runContentChunk(
+	emdash: EmDashHandlers,
+	body: ExecuteBody,
+	config: WpPluginImportConfig,
+	postTypes: string[],
+	manifest: EmDashManifest,
+): Promise<ChunkResponse> {
+	const cursor = body.cursor ?? { postTypeIndex: 0, page: 1 };
+	const postType = postTypes[cursor.postTypeIndex];
+	if (!postType) {
+		return { success: true, result: emptyImportResult(), done: true };
+	}
+
+	const isFirstChunk = cursor.postTypeIndex === 0 && cursor.page === 1;
+	let taxonomyPlan: TaxonomyImportPlan | undefined;
+	let taxonomyDefsCreated: string[] = [];
+	try {
+		if (isFirstChunk) {
+			const built = await buildTaxonomyPlan(emdash, body.url, body.token, config);
+			taxonomyPlan = built.plan;
+			taxonomyDefsCreated = built.defsCreated;
+		} else {
+			taxonomyPlan = await loadTaxonomyPlanFromDb(emdash.db);
+		}
+	} catch (e) {
+		console.warn("[WP Plugin Import] Taxonomy pre-import failed:", e);
+	}
+
+	const page = await fetchPluginContentPage({
+		siteUrl: body.url,
+		token: body.token,
+		postType,
+		page: cursor.page,
+		perPage: CONTENT_CHUNK_SIZE,
+		includeDrafts: true,
+	});
+
+	// Seed translation-group state from earlier chunks so a translation in
+	// this page links to its sibling imported three chunks ago.
+	const translationGroupMap = new Map(Object.entries(body.translationGroups ?? {}));
+
+	const { result, contentIdMap, collectionByWpId } = await importContent(
+		page.items,
+		config,
+		emdash,
+		manifest,
+		taxonomyPlan,
+		translationGroupMap,
+	);
+
+	if (taxonomyDefsCreated.length > 0) {
+		result.taxonomiesCreated = taxonomyDefsCreated;
+	}
+
+	// Advance: next page of this post type, first page of the next one,
+	// or done. An empty last page (totalPages can shrink while paginating
+	// a live site) still terminates because page >= totalPages.
+	let next: ChunkCursor | undefined;
+	if (cursor.page < page.totalPages) {
+		next = { postTypeIndex: cursor.postTypeIndex, page: cursor.page + 1 };
+	} else if (cursor.postTypeIndex + 1 < postTypes.length) {
+		next = { postTypeIndex: cursor.postTypeIndex + 1, page: 1 };
+	}
+
+	return {
+		success: true,
+		result,
+		done: next === undefined,
+		cursor: next,
+		chunk: {
+			idMap: serializeIdMap(contentIdMap, collectionByWpId),
+			translationGroups: Object.fromEntries(translationGroupMap),
+		},
+	};
+}
+
+/**
+ * Import one page of comments (500 per page, ordered by WP comment ID so
+ * parents precede children across pages). Requires the accumulated idMap
+ * from the content phase; threading roots accumulate in `commentRoots`.
+ */
+async function runCommentsChunk(emdash: EmDashHandlers, body: ExecuteBody): Promise<ChunkResponse> {
+	const page = body.cursor?.page ?? 1;
+	const result = emptyImportResult();
+
+	const { contentIdMap, collectionByWpId } = parseIdMap(body.idMap);
+	const rootIds = new Map<number, string>();
+	for (const [key, value] of Object.entries(body.commentRoots ?? {})) {
+		const wpId = Number(key);
+		if (Number.isFinite(wpId)) rootIds.set(wpId, value);
+	}
+
+	const { items, totalPages } = await fetchPluginCommentsPage(body.url, body.token, page);
+
+	if (items.length > 0) {
+		const commentsResult = await importCommentsFromPlugin(
+			items,
+			emdash.db,
+			contentIdMap,
+			collectionByWpId,
+			rootIds,
+		);
+		result.comments = {
+			imported: commentsResult.imported,
+			skipped: commentsResult.skipped,
+		};
+		for (const commentError of commentsResult.errors) {
+			result.errors.push({ title: `Comment: ${commentError.comment}`, error: commentError.error });
+		}
+		result.success = result.errors.length === 0;
+	}
+
+	const done = page >= totalPages;
+	const commentRoots: Record<string, string> = {};
+	for (const [wpId, id] of rootIds) commentRoots[String(wpId)] = id;
+
+	return {
+		success: true,
+		result,
+		done,
+		cursor: done ? undefined : { postTypeIndex: 0, page: page + 1 },
+		chunk: { commentRoots },
+	};
+}
+
+/** Menus + site identity — small, runs as a single closing chunk. */
+async function runFinalizePhase(
+	emdash: EmDashHandlers,
+	body: ExecuteBody,
+	config: WpPluginImportConfig,
+): Promise<ChunkResponse> {
+	const result = emptyImportResult();
+	const { contentIdMap } = parseIdMap(body.idMap);
+
+	if (config.importMenus !== false) {
+		await importMenusInto(result, emdash, body.url, body.token, contentIdMap);
+	}
+
+	try {
+		result.siteSettings = await applySiteSettings(emdash, body.url, body.token, config);
+	} catch (e) {
+		console.warn("[WP Plugin Import] Site settings import failed:", e);
+	}
+
+	result.success = result.errors.length === 0;
+	return { success: true, result, done: true };
+}
+
 /** Fields that should be auto-created if they don't exist */
 const IMPORT_FIELDS: Array<{
 	slug: string;
@@ -134,14 +505,285 @@ const IMPORT_FIELDS: Array<{
 		type: "image",
 		check: (item) => !!item.featuredImage,
 	},
+	{
+		slug: "seo_title",
+		label: "SEO Title",
+		type: "string",
+		check: (item) => !!extractSeo(item).title,
+	},
+	{
+		slug: "seo_description",
+		label: "SEO Description",
+		type: "text",
+		check: (item) => !!extractSeo(item).description,
+	},
 ];
 
-async function importContent(
-	items: AsyncGenerator<NormalizedItem>,
+const SEO_FIELD_SLUGS = new Set(["seo_title", "seo_description"]);
+
+/**
+ * Coerce a WordPress meta value to an EmDash field type. WP postmeta is
+ * stringly typed and inconsistent across posts (the same key can hold
+ * "5", 5, "", or false). Returns `undefined` when the value can't
+ * reasonably represent the target type — the caller drops it.
+ */
+export function coerceToFieldType(value: unknown, fieldType: string): unknown {
+	switch (fieldType) {
+		case "integer": {
+			const n = typeof value === "number" ? value : Number(value);
+			return Number.isInteger(n) ? n : undefined;
+		}
+		case "number": {
+			const n = typeof value === "number" ? value : Number(value);
+			return Number.isFinite(n) ? n : undefined;
+		}
+		case "boolean": {
+			if (typeof value === "boolean") return value;
+			if (value === 1 || value === "1" || value === "true" || value === "yes") return true;
+			if (value === 0 || value === "0" || value === "false" || value === "no") return false;
+			return undefined;
+		}
+		case "datetime": {
+			if (typeof value !== "string" && typeof value !== "number") return undefined;
+			const d = new Date(value);
+			return Number.isNaN(d.getTime()) ? undefined : d.toISOString();
+		}
+		case "json":
+			// Anything serializes; objects/arrays pass through as-is
+			return value;
+		case "string":
+		case "text":
+		case "url":
+		case "select":
+		case "slug":
+		case "reference":
+			if (typeof value === "string") return value;
+			if (typeof value === "number") return String(value);
+			return undefined;
+		default:
+			// Complex types (image, portableText, repeater, multiSelect, file):
+			// raw meta can't be coerced reliably -- pass through only if it
+			// already has a non-primitive shape.
+			return typeof value === "object" ? value : undefined;
+	}
+}
+
+/**
+ * Pull the per-post SEO title/description out of the Yoast / Rank Math
+ * blobs the plugin source stashes in `item.meta`. Empty strings mean "not
+ * overridden for this post" (the plugin exports the raw meta values) and
+ * are treated as absent.
+ */
+function pickSeoValue(blob: unknown, key: string): string | undefined {
+	if (typeof blob !== "object" || blob === null) return undefined;
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- narrowed to non-null object above
+	const value = (blob as Record<string, unknown>)[key];
+	return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+
+function extractSeo(item: NormalizedItem): { title?: string; description?: string } {
+	const yoast = item.meta?._yoast;
+	const rankmath = item.meta?._rankmath;
+	return {
+		title: pickSeoValue(yoast, "title") ?? pickSeoValue(rankmath, "title"),
+		description: pickSeoValue(yoast, "description") ?? pickSeoValue(rankmath, "description"),
+	};
+}
+
+/**
+ * Fetch the site's taxonomies from the plugin API and pre-create all terms,
+ * reusing the WXR taxonomy machinery (same def-lookup, idempotency, and
+ * collection-filter semantics).
+ */
+/** WP built-in taxonomies that either map to seeded defs or are not content taxonomies. */
+const BUILTIN_TAXONOMIES = new Set(["category", "post_tag", "nav_menu", "post_format"]);
+
+/** Mirrors NAME_PATTERN in the taxonomy handler -- names that fail stay in missingTaxonomies. */
+const TAXONOMY_NAME_PATTERN = /^[a-z][a-z0-9_]*$/;
+
+/**
+ * Create EmDash taxonomy defs for custom WP taxonomies (e.g. CPT taxonomies
+ * like `company` or `plattform`) that don't exist yet, scoped to the
+ * collections the enabled post-type mappings target. Returns the names of
+ * the defs created. Runs before term pre-import so the terms and per-post
+ * assignments flow through the existing machinery instead of being dropped
+ * as `missingTaxonomies`.
+ */
+export async function ensureCustomTaxonomyDefs(
+	db: EmDashHandlers["db"],
+	taxonomies: Awaited<ReturnType<typeof fetchPluginTaxonomies>>,
+	config: WpPluginImportConfig,
+): Promise<string[]> {
+	const created: string[] = [];
+	for (const taxonomy of taxonomies) {
+		if (BUILTIN_TAXONOMIES.has(taxonomy.name)) continue;
+		if (taxonomy.terms.length === 0) continue;
+		if (!TAXONOMY_NAME_PATTERN.test(taxonomy.name)) continue;
+
+		// handleTaxonomyCreate's duplicate guard is locale-scoped; check
+		// name-wide existence ourselves to stay idempotent on re-runs.
+		const existing = await db
+			.selectFrom("_emdash_taxonomy_defs")
+			.select("id")
+			.where("name", "=", taxonomy.name)
+			.executeTakeFirst();
+		if (existing) continue;
+
+		// Scope the def to the collections the WP post types map onto.
+		// Older plugin versions don't send post_types -> empty list = no
+		// collection filter, which the term machinery treats as "any".
+		const collections = (taxonomy.post_types ?? [])
+			.map((postType) => config.postTypeMappings[postType])
+			.filter((mapping) => mapping?.enabled)
+			.map((mapping) => mapping.collection);
+
+		const result = await handleTaxonomyCreate(db, {
+			name: taxonomy.name,
+			label: taxonomy.label,
+			labelSingular: taxonomy.label_singular,
+			hierarchical: taxonomy.hierarchical,
+			collections: [...new Set(collections)],
+		});
+		if (result.success) {
+			created.push(taxonomy.name);
+		} else {
+			console.warn(
+				`[WP Plugin Import] Could not create taxonomy '${taxonomy.name}':`,
+				result.error.message,
+			);
+		}
+	}
+	return created;
+}
+
+async function buildTaxonomyPlan(
+	emdash: EmDashHandlers,
+	url: string,
+	token: string,
+	config: WpPluginImportConfig,
+): Promise<{ plan: TaxonomyImportPlan; defsCreated: string[] }> {
+	const taxonomies = await fetchPluginTaxonomies(url, token);
+
+	const defsCreated = await ensureCustomTaxonomyDefs(emdash.db, taxonomies, config);
+
+	const categories: WxrCategory[] = [];
+	const tags: WxrTag[] = [];
+	const terms: WxrTerm[] = [];
+
+	for (const taxonomy of taxonomies) {
+		for (const term of taxonomy.terms) {
+			if (taxonomy.name === "category") {
+				categories.push({ nicename: term.slug, name: term.name, description: term.description });
+			} else if (taxonomy.name === "post_tag") {
+				tags.push({ slug: term.slug, name: term.name, description: term.description });
+			} else if (taxonomy.name !== "nav_menu" && taxonomy.name !== "post_format") {
+				terms.push({
+					id: term.id,
+					taxonomy: taxonomy.name,
+					slug: term.slug,
+					name: term.name,
+					description: term.description,
+				});
+			}
+		}
+	}
+
+	const plan = await preImportWxrTaxonomies(emdash.db, [], categories, tags, terms, undefined);
+	return { plan, defsCreated };
+}
+
+/**
+ * Fetch the source site's options and apply its identity (title, tagline,
+ * logo, favicon) as EmDash site settings, overwriting seed placeholders.
+ * Logo/favicon files are side-loaded into media storage first; the later
+ * full media pass dedupes them by content hash.
+ *
+ * Returns the list of applied setting keys.
+ */
+async function applySiteSettings(
+	emdash: EmDashHandlers,
+	url: string,
+	token: string,
+	config: WpPluginImportConfig,
+): Promise<string[]> {
+	const wantTitle = config.importSiteTitle !== false;
+	const wantLogo = config.importLogo !== false;
+	if (!wantTitle && !wantLogo) return [];
+
+	const options = await fetchPluginOptions(url, token);
+	const parsed = parseSiteSettingsFromPlugin(options);
+	if (!wantTitle) {
+		delete parsed.title;
+		delete parsed.tagline;
+	}
+	if (!wantLogo) {
+		delete parsed.logo;
+		delete parsed.favicon;
+	}
+
+	const media: { logoMediaId?: string; faviconMediaId?: string } = {};
+	if (emdash.storage && (parsed.logo?.url || parsed.favicon?.url)) {
+		const attachments = [];
+		if (parsed.logo?.url) {
+			attachments.push({ id: parsed.logo.id, url: parsed.logo.url });
+		}
+		if (parsed.favicon?.url && parsed.favicon.url !== parsed.logo?.url) {
+			attachments.push({ id: parsed.favicon.id, url: parsed.favicon.url });
+		}
+		const mediaResult = await importMediaWithProgress(
+			attachments,
+			emdash.db,
+			emdash.storage,
+			() => {},
+		);
+		for (const item of mediaResult.imported) {
+			if (item.originalUrl === parsed.logo?.url) {
+				media.logoMediaId = item.mediaId;
+			}
+			if (item.originalUrl === parsed.favicon?.url) {
+				media.faviconMediaId = item.mediaId;
+			}
+		}
+	}
+
+	const settingsResult = await importSiteSettings(parsed, emdash.db, true, media);
+	for (const settingError of settingsResult.errors) {
+		console.warn(
+			`[WP Plugin Import] Site setting "${settingError.setting}" failed:`,
+			settingError.error,
+		);
+	}
+	return settingsResult.applied;
+}
+
+/**
+ * Adapt a NormalizedItem's taxonomy assignments to the WxrPost shape the
+ * shared attach helper consumes.
+ */
+function toWxrAssignments(item: NormalizedItem): WxrPost {
+	return {
+		categories: item.categories ?? [],
+		tags: item.tags ?? [],
+		customTaxonomies: item.customTaxonomies
+			? new Map(Object.entries(item.customTaxonomies))
+			: undefined,
+		meta: new Map(),
+	};
+}
+
+/** Exported for tests (field auto-creation regression coverage). */
+export async function importContent(
+	items: AsyncIterable<NormalizedItem> | Iterable<NormalizedItem>,
 	config: WpPluginImportConfig,
 	emdash: EmDashHandlers,
 	manifest: EmDashManifest,
-): Promise<ImportResult> {
+	taxonomyPlan: TaxonomyImportPlan | undefined,
+	seedTranslationGroups?: Map<string, string>,
+): Promise<{
+	result: ImportResult;
+	contentIdMap: Map<number, string>;
+	collectionByWpId: Map<number, string>;
+}> {
 	const result: ImportResult = {
 		success: true,
 		imported: 0,
@@ -150,19 +792,32 @@ async function importContent(
 		byCollection: {},
 	};
 
+	// WP post ID -> EmDash content ID, used to resolve menu item references
+	const contentIdMap = new Map<number, string>();
+
+	// WP post ID -> EmDash collection slug, used by the comment import
+	const collectionByWpId = new Map<number, string>();
+
 	// Create content repository for checking existing items
 	const contentRepo = new ContentRepository(emdash.db);
 	const bylineRepo = new BylineRepository(emdash.db);
 	const bylineCache = new Map<string, string>();
 	const schemaRegistry = new SchemaRegistry(emdash.db);
 
-	// Track which collections have had fields ensured
-	const ensuredCollections = new Set<string>();
+	// Track which (collection, field) pairs have been ensured. Keyed per
+	// field, not per collection: a field like seo_title may first be
+	// needed by the 30th item, and gating on the first item would skip it.
+	const ensuredFields = new Set<string>();
+
+	// Field slug -> type per collection, for mapping custom meta/ACF onto
+	// real fields (and coercing values to the field's type)
+	const fieldTypesByCollection = new Map<string, Map<string, string>>();
 
 	// Track source translationGroup -> EmDash item ID for translation linking.
 	// Maps source-side translation group ID to the EmDash ID of the first item
-	// imported for that group (the default-locale item).
-	const translationGroupMap = new Map<string, string>();
+	// imported for that group (the default-locale item). The chunked import
+	// seeds this from earlier chunks so groups can span page boundaries.
+	const translationGroupMap = seedTranslationGroups ?? new Map<string, string>();
 
 	for await (const item of items) {
 		console.log("[WP Plugin Import] Processing item:", {
@@ -196,33 +851,51 @@ async function importContent(
 		}
 
 		try {
-			// Ensure required fields exist in the collection schema (once per collection)
-			if (!ensuredCollections.has(collection)) {
-				for (const field of IMPORT_FIELDS) {
-					if (field.check(item)) {
-						const existingField = await schemaRegistry.getField(collection, field.slug);
-						if (!existingField) {
-							console.log(
-								`[WP Plugin Import] Creating missing field "${field.slug}" in collection "${collection}"`,
-							);
-							try {
-								await schemaRegistry.createField(collection, {
-									slug: field.slug,
-									label: field.label,
-									type: field.type,
-									required: false,
-								});
-							} catch (e) {
-								// Field might already exist from concurrent creation
-								console.log(
-									`[WP Plugin Import] Field "${field.slug}" creation skipped:`,
-									e instanceof Error ? e.message : e,
-								);
-							}
-						}
+			// Ensure required fields exist in the collection schema. Checked
+			// per field and item (not once per collection): whether a field
+			// is needed depends on the item — the first post may have no SEO
+			// override while a later one does.
+			for (const field of IMPORT_FIELDS) {
+				if (config.importSeo === false && SEO_FIELD_SLUGS.has(field.slug)) continue;
+				const ensureKey = `${collection}:${field.slug}`;
+				if (ensuredFields.has(ensureKey) || !field.check(item)) continue;
+				ensuredFields.add(ensureKey);
+				const existingField = await schemaRegistry.getField(collection, field.slug);
+				if (!existingField) {
+					console.log(
+						`[WP Plugin Import] Creating missing field "${field.slug}" in collection "${collection}"`,
+					);
+					try {
+						await schemaRegistry.createField(collection, {
+							slug: field.slug,
+							label: field.label,
+							type: field.type,
+							required: false,
+						});
+						fieldTypesByCollection.get(collection)?.set(field.slug, field.type);
+					} catch (e) {
+						// Field might already exist from concurrent creation
+						console.log(
+							`[WP Plugin Import] Field "${field.slug}" creation skipped:`,
+							e instanceof Error ? e.message : e,
+						);
 					}
 				}
-				ensuredCollections.add(collection);
+			}
+
+			// Load the collection's field types once, so custom meta / ACF
+			// values can land in matching schema fields (created by the
+			// prepare step or already present).
+			let fieldTypes = fieldTypesByCollection.get(collection);
+			if (!fieldTypes) {
+				fieldTypes = new Map<string, string>();
+				const collectionDef = await schemaRegistry.getCollection(collection);
+				if (collectionDef) {
+					for (const field of await schemaRegistry.listFields(collectionDef.id)) {
+						fieldTypes.set(field.slug, field.type);
+					}
+				}
+				fieldTypesByCollection.set(collection, fieldTypes);
 			}
 
 			// Generate slug from item slug or title
@@ -236,6 +909,12 @@ async function importContent(
 					if (item.translationGroup) {
 						translationGroupMap.set(item.translationGroup, existing.id);
 					}
+					// Menus and comments may reference this post even when we skip it
+					const wpId = Number(item.sourceId);
+					if (Number.isFinite(wpId)) {
+						contentIdMap.set(wpId, existing.id);
+						collectionByWpId.set(wpId, collection);
+					}
 					result.skipped++;
 					continue;
 				}
@@ -259,8 +938,49 @@ async function importContent(
 				console.log("[WP Plugin Import] Adding featured_image:", item.featuredImage);
 			}
 
-			// Note: ACF/Yoast/RankMath fields are not added automatically
-			// They would need matching fields in the EmDash schema
+			// Per-post SEO overrides from Yoast / Rank Math
+			if (config.importSeo !== false) {
+				const seo = extractSeo(item);
+				if (seo.title) {
+					data.seo_title = seo.title;
+				}
+				if (seo.description) {
+					data.seo_description = seo.description;
+				}
+			}
+
+			// Map ACF values and custom meta onto schema fields with the same
+			// (sanitized) slug — the same sanitization the analysis applied
+			// when suggesting the fields, so keys like `event-date` land in
+			// the `event_date` field the prepare step created. Values without
+			// a matching field are dropped -- the user controls the schema,
+			// we don't invent fields per meta key. Values are coerced to the
+			// field's type (the analysis inferred it from ONE sample; real
+			// values vary) and dropped when incoercible, so one odd meta
+			// value can't fail the whole item.
+			const assignMetaValue = (key: string, value: unknown) => {
+				if (value === null || value === "") return;
+				const fieldSlug = sanitizeFieldSlug(key);
+				const fieldType = fieldTypes.get(fieldSlug);
+				if (!fieldType || fieldSlug in data) return;
+				const coerced = coerceToFieldType(value, fieldType);
+				if (coerced !== undefined) {
+					data[fieldSlug] = coerced;
+				}
+			};
+			const acf = item.meta?._acf;
+			if (typeof acf === "object" && acf !== null) {
+				for (const [key, value] of Object.entries(acf)) {
+					assignMetaValue(key, value);
+				}
+			}
+			if (item.meta) {
+				for (const [key, value] of Object.entries(item.meta)) {
+					// Underscore keys are WP-internal or handled above (_acf/_yoast/_rankmath)
+					if (key.startsWith("_")) continue;
+					assignMetaValue(key, value);
+				}
+			}
 
 			// Resolve author ID from mappings
 			let authorId: string | undefined;
@@ -314,13 +1034,39 @@ async function importContent(
 				result.imported++;
 				result.byCollection[collection] = (result.byCollection[collection] || 0) + 1;
 
-				// Track translation group: first item in a group establishes the mapping
-				if (item.translationGroup && !translationGroupMap.has(item.translationGroup)) {
-					// eslint-disable-next-line typescript/no-unsafe-type-assertion -- handler success data includes id
-					const createdData = createResult.data as { id?: string } | undefined;
-					if (createdData?.id) {
-						translationGroupMap.set(item.translationGroup, createdData.id);
+				// eslint-disable-next-line typescript/no-unsafe-type-assertion -- create handler returns { item, _rev }
+				const createdData = createResult.data as { item?: { id?: string } } | undefined;
+				const createdId = createdData?.item?.id;
+
+				if (createdId) {
+					const wpId = Number(item.sourceId);
+					if (Number.isFinite(wpId)) {
+						contentIdMap.set(wpId, createdId);
+						collectionByWpId.set(wpId, collection);
 					}
+
+					// Attach category/tag/custom-taxonomy assignments
+					if (taxonomyPlan) {
+						try {
+							const attached = await attachPostTaxonomies(
+								emdash.db,
+								collection,
+								createdId,
+								toWxrAssignments(item),
+								taxonomyPlan,
+							);
+							if (attached > 0) {
+								result.taxonomyAssignments = (result.taxonomyAssignments ?? 0) + attached;
+							}
+						} catch (e) {
+							console.warn(`[WP Plugin Import] Taxonomy attach failed for "${slug}":`, e);
+						}
+					}
+				}
+
+				// Track translation group: first item in a group establishes the mapping
+				if (item.translationGroup && !translationGroupMap.has(item.translationGroup) && createdId) {
+					translationGroupMap.set(item.translationGroup, createdId);
 				}
 			} else {
 				result.errors.push({
@@ -340,8 +1086,12 @@ async function importContent(
 		}
 	}
 
+	if (taxonomyPlan && taxonomyPlan.missingTaxonomies.length > 0) {
+		result.missingTaxonomies = taxonomyPlan.missingTaxonomies;
+	}
+
 	result.success = result.errors.length === 0;
-	return result;
+	return { result, contentIdMap, collectionByWpId };
 }
 
 function mapStatus(wpStatus: string | undefined): string {