@contentrain/wp-import 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1654 @@
+import sax from "sax";
+import { COMMENTS_EXPORT_FORMAT, MIGRATION_CONTRACT_VERSION } from "@contentrain/types";
+import { createHash } from "node:crypto";
+//#region src/php-unserialize.ts
+function looksSerialized(s) {
+	return typeof s === "string" && /^(a|O):\d+:[{"]|^(s|i|d|b):[^;]+;?$|^N;$/.test(s);
+}
+function phpUnserialize(str) {
+	const buf = Buffer.from(str, "utf8");
+	let p = 0;
+	const fail = (m) => {
+		throw new Error(`unserialize: ${m} at byte ${p}`);
+	};
+	const readUntil = (ch) => {
+		const i = buf.indexOf(ch, p);
+		if (i < 0) fail(`expected ${ch}`);
+		const s = buf.toString("utf8", p, i);
+		p = i + 1;
+		return s;
+	};
+	const expect = (ch) => {
+		if (buf[p] !== ch.charCodeAt(0)) fail(`expected '${ch}' got '${String.fromCharCode(buf[p] ?? 0)}'`);
+		p++;
+	};
+	const value = () => {
+		const t = String.fromCharCode(buf[p] ?? 0);
+		p++;
+		switch (t) {
+			case "N":
+				expect(";");
+				return null;
+			case "b":
+				expect(":");
+				return readUntil(";") === "1";
+			case "i":
+				expect(":");
+				return Number(readUntil(";"));
+			case "d": {
+				expect(":");
+				const v = readUntil(";");
+				return v === "INF" ? Infinity : v === "-INF" ? -Infinity : v === "NAN" ? NaN : Number(v);
+			}
+			case "s": {
+				expect(":");
+				const n = Number(readUntil(":"));
+				expect("\"");
+				const s = buf.toString("utf8", p, p + n);
+				p += n;
+				expect("\"");
+				expect(";");
+				return s;
+			}
+			case "a": {
+				expect(":");
+				const n = Number(readUntil(":"));
+				expect("{");
+				const entries = [];
+				for (let i = 0; i < n; i++) {
+					const k = value();
+					const v = value();
+					entries.push([k, v]);
+				}
+				expect("}");
+				return entries.every(([k], i) => k === i) ? entries.map(([, v]) => v) : Object.fromEntries(entries.map(([k, v]) => [String(k), v]));
+			}
+			case "O": {
+				expect(":");
+				readUntil(":");
+				expect("\"");
+				const cls = readUntil("\"");
+				expect(":");
+				const n = Number(readUntil(":"));
+				expect("{");
+				const o = { __class: cls };
+				for (let i = 0; i < n; i++) {
+					const k = value();
+					const v = value();
+					o[String(k).split("\0").at(-1) ?? String(k)] = v;
+				}
+				expect("}");
+				return o;
+			}
+			default: return fail(`unknown type '${t}'`);
+		}
+	};
+	const v = value();
+	if (p !== buf.length) fail(`trailing ${buf.length - p} bytes`);
+	return v;
+}
+/** Attempt a decode; on failure the value stays exactly as it was. */
+function tryUnserialize(s) {
+	if (!looksSerialized(s)) return {
+		ok: false,
+		serialized: false,
+		value: s
+	};
+	try {
+		return {
+			ok: true,
+			serialized: true,
+			value: phpUnserialize(s)
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			serialized: true,
+			value: s,
+			error: e instanceof Error ? e.message : String(e)
+		};
+	}
+}
+//#endregion
+//#region src/core.ts
+const norm = (s) => String(s ?? "").replace(/\s+/g, " ").trim();
+const strip = (s) => norm(String(s ?? "").replace(/<[^>]*>/g, " ").replace(/&#(\d+);/g, (_m, d) => String.fromCodePoint(Number(d))).replace(/&amp;/g, "&"));
+/** Entry id: deterministic hex from a stable key (model:slug style). */
+const hexId = (s) => createHash("sha1").update(s).digest("hex").slice(0, 24);
+const sortDeep = (v) => Array.isArray(v) ? v.map(sortDeep) : v && typeof v === "object" ? Object.fromEntries(Object.keys(v).toSorted().map((k) => [k, sortDeep(v[k])])) : v;
+/** Canonical serialization: sorted keys, 2-space indent, trailing newline. */
+const canon = (o) => `${JSON.stringify(sortDeep(o), null, 2)}\n`;
+/** Field-type inference from a value (open meta / ACF fields). */
+const byValue = (v) => {
+	if (typeof v === "boolean") return "boolean";
+	if (typeof v === "number") return Number.isInteger(v) ? "integer" : "decimal";
+	if (Array.isArray(v)) return "array";
+	if (v && typeof v === "object") return "object";
+	const s = String(v ?? "").trim();
+	if (!s) return null;
+	if (/^https?:\/\/\S+\.(mp3|m4a|wav|pdf|zip|docx?)(\?|$)/i.test(s)) return "file";
+	if (/^https?:\/\/\S+\.(jpe?g|png|gif|webp|avif|svg)(\?|$)/i.test(s)) return "image";
+	if (/^https?:\/\//.test(s)) return "url";
+	if (/^[^@\s]+@[^@\s]+\.[a-z]{2,}$/i.test(s)) return "email";
+	if (/^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2})/.test(s)) return "datetime";
+	if (/<[a-z][\s\S]*>/i.test(s)) return "richtext";
+	return s.length > 200 ? "text" : "string";
+};
+/** WP post types that never become content models. */
+const SKIP_TYPES = /^(attachment|nav_menu_item|wp_|jp_|pattern|revision|oembed_cache|customize_changeset|user_request|custom_css)/;
+/** Open meta keys that are plugin plumbing, not editorial fields. */
+const PLUGIN_META = /^(jetpack|wpdc|discourse|footnotes|inline_featured|spay_|advanced_seo|rank_math|yoast)/i;
+/** Taxonomy → model id. */
+const taxModelId = (t) => t === "post_tag" ? "tags" : t === "category" ? "categories" : t.replace(/_/g, "-");
+const slugify = (s) => String(s ?? "").normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+const decodeSlug = (s) => {
+	try {
+		return decodeURIComponent(s);
+	} catch {
+		return s;
+	}
+};
+/** The measured core field skeleton for content models (same order/labels). */
+function coreFields(opts) {
+	const fields = {
+		title: {
+			type: "string",
+			required: true,
+			label: "Title",
+			order: 10
+		},
+		slug: {
+			type: "slug",
+			required: true,
+			unique: true,
+			label: "Slug",
+			order: 20
+		}
+	};
+	let o = 30;
+	if (opts.excerpt) fields.excerpt = {
+		type: "text",
+		label: "Excerpt",
+		order: o += 10
+	};
+	if (opts.body) fields.body = {
+		type: "richtext",
+		label: "Body",
+		order: o += 10
+	};
+	if (opts.date) fields.published_at = {
+		type: "datetime",
+		label: "Published at",
+		order: o += 10
+	};
+	if (opts.author) fields.author = {
+		type: "relation",
+		model: "authors",
+		label: "Author",
+		order: o += 10
+	};
+	for (const t of opts.taxes) fields[taxModelId(t)] = {
+		type: "relations",
+		model: taxModelId(t),
+		label: t,
+		order: o += 10
+	};
+	if (opts.cover) fields.cover = {
+		type: "relation",
+		model: "media",
+		label: "Cover",
+		order: o += 10
+	};
+	return {
+		fields,
+		order: o
+	};
+}
+//#endregion
+//#region src/wxr.ts
+const ts = (s) => !s || s.startsWith("0000-00-00") ? null : s.replace(" ", "T");
+const iso$1 = (local, gmt) => gmt && !gmt.startsWith("0000") ? `${ts(gmt)}Z` : ts(local);
+const num = (s) => s === "" || s == null ? 0 : Number(s);
+const termKey = (tax, slug) => `${tax}:${slug}`;
+async function parseWxr(input, opts) {
+	const site = {};
+	const authors = [];
+	const terms = [];
+	const items = [];
+	const stats = {
+		serialized: {
+			detected: 0,
+			decoded: 0,
+			failed: 0,
+			keys: []
+		},
+		acf_fields: 0,
+		unresolved_terms: 0,
+		counts: {}
+	};
+	const serializedKeySet = /* @__PURE__ */ new Set();
+	const parser = sax.createStream(true, { trim: false });
+	const path = [];
+	let text = "";
+	let item = null;
+	let meta = null;
+	let comment = null;
+	let cmeta = null;
+	let author = null;
+	let term = null;
+	const channelText = {};
+	const leaf = (name, into, map) => {
+		const target = map[name];
+		if (target) into[target] = text;
+	};
+	parser.on("opentag", (node) => {
+		path.push(node.name);
+		text = "";
+		const n = node.name;
+		if (n === "item") item = {
+			terms: [],
+			postmeta: [],
+			comments: []
+		};
+		else if (n === "wp:postmeta") meta = {};
+		else if (n === "wp:comment") comment = { meta: [] };
+		else if (n === "wp:commentmeta") cmeta = {};
+		else if (n === "wp:author") author = {};
+		else if (n === "wp:category" || n === "wp:tag" || n === "wp:term") term = { _tag: n };
+		else if (n === "category" && item) {
+			const attrs = node.attributes;
+			item.terms.push({
+				taxonomy: attrs.domain ?? "",
+				slug: attrs.nicename ?? ""
+			});
+		}
+	});
+	parser.on("text", (t) => {
+		text += t;
+	});
+	parser.on("cdata", (t) => {
+		text += t;
+	});
+	parser.on("comment", (c) => {
+		const m = /generator="([^"]*)"\s+created="([^"]*)"/.exec(c);
+		if (m) {
+			site.generator = m[1];
+			site.export_date = m[2];
+		}
+	});
+	parser.on("closetag", (n) => {
+		const parent = path[path.length - 2];
+		if (cmeta) {
+			if (n === "wp:meta_key") cmeta.key = text;
+			else if (n === "wp:meta_value") cmeta.value = text;
+			else if (n === "wp:commentmeta") {
+				comment.meta.push(cmeta);
+				cmeta = null;
+			}
+		} else if (comment) {
+			leaf(n, comment, {
+				"wp:comment_id": "id",
+				"wp:comment_author": "author",
+				"wp:comment_author_email": "email",
+				"wp:comment_author_url": "url",
+				"wp:comment_date": "date",
+				"wp:comment_date_gmt": "date_gmt",
+				"wp:comment_content": "content",
+				"wp:comment_approved": "approved",
+				"wp:comment_type": "type",
+				"wp:comment_parent": "parent",
+				"wp:comment_user_id": "user_id"
+			});
+			if (n === "wp:comment") {
+				item.comments.push(comment);
+				comment = null;
+			}
+		} else if (meta) {
+			if (n === "wp:meta_key") meta.key = text;
+			else if (n === "wp:meta_value") meta.value = text;
+			else if (n === "wp:postmeta") {
+				item.postmeta.push(meta);
+				meta = null;
+			}
+		} else if (item) if (n === "category") {
+			const t = item.terms.at(-1);
+			if (t) t.name = text;
+		} else {
+			leaf(n, item, {
+				title: "title",
+				link: "link",
+				"dc:creator": "author",
+				guid: "guid",
+				description: "description",
+				"content:encoded": "content",
+				"excerpt:encoded": "excerpt",
+				"wp:post_id": "id",
+				"wp:post_date": "date",
+				"wp:post_date_gmt": "date_gmt",
+				"wp:post_modified": "modified",
+				"wp:post_modified_gmt": "modified_gmt",
+				"wp:comment_status": "comment_status",
+				"wp:ping_status": "ping_status",
+				"wp:post_name": "slug",
+				"wp:status": "status",
+				"wp:post_parent": "parent",
+				"wp:menu_order": "menu_order",
+				"wp:post_type": "type",
+				"wp:post_password": "password",
+				"wp:is_sticky": "sticky",
+				"wp:attachment_url": "attachment_url"
+			});
+			if (n === "item") {
+				items.push(item);
+				item = null;
+			}
+		}
+		else if (author) {
+			leaf(n, author, {
+				"wp:author_id": "id",
+				"wp:author_login": "login",
+				"wp:author_email": "email",
+				"wp:author_display_name": "display_name",
+				"wp:author_first_name": "first_name",
+				"wp:author_last_name": "last_name"
+			});
+			if (n === "wp:author") {
+				authors.push(author);
+				author = null;
+			}
+		} else if (term) {
+			leaf(n, term, {
+				"wp:term_id": "id",
+				"wp:category_nicename": "slug",
+				"wp:category_parent": "parent",
+				"wp:cat_name": "name",
+				"wp:category_description": "description",
+				"wp:tag_slug": "slug",
+				"wp:tag_name": "name",
+				"wp:tag_description": "description",
+				"wp:term_taxonomy": "taxonomy",
+				"wp:term_slug": "slug",
+				"wp:term_parent": "parent",
+				"wp:term_name": "name",
+				"wp:term_description": "description"
+			});
+			if (n === term._tag) {
+				term.taxonomy = term._tag === "wp:category" ? "category" : term._tag === "wp:tag" ? "post_tag" : term.taxonomy ?? "";
+				delete term._tag;
+				terms.push(term);
+				term = null;
+			}
+		} else if (parent === "channel") leaf(n, channelText, {
+			title: "title",
+			link: "link",
+			description: "description",
+			language: "language",
+			"wp:wxr_version": "wxr_version",
+			"wp:base_site_url": "base_site_url",
+			"wp:base_blog_url": "base_blog_url"
+		});
+		path.pop();
+		text = "";
+	});
+	await new Promise((resolve, reject) => {
+		parser.on("end", () => resolve());
+		parser.on("error", reject);
+		if (typeof input === "string") parser.end(input);
+		else input.pipe(parser);
+	});
+	Object.assign(site, channelText);
+	const decodeMeta = (list) => {
+		const out = {};
+		const serializedKeys = [];
+		for (const { key, value } of list) {
+			if (!key) continue;
+			const r = tryUnserialize(value ?? "");
+			if (r.serialized) {
+				stats.serialized.detected++;
+				serializedKeySet.add(key);
+				if (r.ok) {
+					stats.serialized.decoded++;
+					serializedKeys.push(key);
+				} else stats.serialized.failed++;
+			}
+			const v = r.ok ? r.value : value ?? "";
+			out[key] = key in out ? [].concat(out[key], [v]) : v;
+		}
+		return {
+			meta: out,
+			serializedKeys
+		};
+	};
+	const extractAcf = (metaObj) => {
+		const acf = {};
+		for (const [k, v] of Object.entries(metaObj)) if (k.startsWith("_") && typeof v === "string" && /^field_[0-9a-f]+$/.test(v) && k.slice(1) in metaObj) acf[k.slice(1)] = {
+			value: metaObj[k.slice(1)],
+			field_key: v
+		};
+		return acf;
+	};
+	const termSet = new Set(terms.map((t) => termKey(t.taxonomy ?? "", t.slug ?? "")));
+	const records = items.map((it) => {
+		const { meta: m, serializedKeys } = decodeMeta(it.postmeta);
+		const acf = extractAcf(m);
+		stats.acf_fields += Object.keys(acf).length;
+		const id = num(it.id);
+		const termRefs = it.terms.map((t) => ({
+			taxonomy: t.taxonomy,
+			slug: t.slug,
+			name: t.name ?? "",
+			resolved: termSet.has(termKey(t.taxonomy, t.slug))
+		}));
+		const comments = it.comments.map((c) => ({
+			id: num(c.id),
+			post: id,
+			post_type: it.type || "post",
+			parent: num(c.parent) || null,
+			parent_resolved: null,
+			author: c.author ?? "",
+			email: c.email || null,
+			url: c.url || null,
+			date: iso$1(c.date, c.date_gmt),
+			date_gmt: ts(c.date_gmt),
+			content: c.content ?? "",
+			approved: c.approved ?? "1",
+			type: c.type || "comment",
+			user_id: num(c.user_id) || null,
+			meta: decodeMeta(c.meta ?? []).meta
+		}));
+		return {
+			id,
+			type: it.type || "post",
+			status: it.status || "publish",
+			slug: it.slug || "",
+			title: it.title ?? "",
+			link: it.link || null,
+			guid: it.guid || null,
+			author: it.author || null,
+			date: iso$1(it.date, it.date_gmt),
+			modified: iso$1(it.modified, it.modified_gmt),
+			content: it.content ?? "",
+			excerpt: it.excerpt ?? "",
+			parent: num(it.parent) || null,
+			menu_order: num(it.menu_order),
+			sticky: it.sticky === "1",
+			password: it.password || null,
+			comment_status: it.comment_status || null,
+			ping_status: it.ping_status || null,
+			terms: termRefs,
+			meta: m,
+			serialized_keys: serializedKeys,
+			acf,
+			attachment_url: it.attachment_url || null,
+			_comments: comments
+		};
+	});
+	for (const r of records) for (const t of r.terms) if (!t.resolved && r.type !== "nav_menu_item") stats.unresolved_terms++;
+	const byId = new Map(records.map((r) => [r.id, r]));
+	const posts = records.filter((r) => r.type !== "attachment" && r.type !== "nav_menu_item").map(({ attachment_url: _a, _comments: _c, ...p }) => p);
+	const attachments = records.filter((r) => r.type === "attachment").map((r) => ({
+		id: r.id,
+		title: r.title,
+		slug: r.slug,
+		url: r.attachment_url ?? r.guid ?? null,
+		alt: typeof r.meta._wp_attachment_image_alt === "string" ? r.meta._wp_attachment_image_alt : "",
+		caption: r.excerpt,
+		description: r.content,
+		file: typeof r.meta._wp_attached_file === "string" ? r.meta._wp_attached_file : null,
+		image_meta: r.meta._wp_attachment_metadata ?? null,
+		mime: guessMime(r.attachment_url ?? r.guid ?? ""),
+		parent: r.parent,
+		parent_resolved: r.parent ? byId.has(r.parent) : null,
+		author: r.author,
+		date: r.date,
+		status: r.status,
+		meta: r.meta
+	}));
+	const postById = new Map(posts.map((p) => [p.id, p]));
+	const termByIdNum = new Map(terms.map((t) => [num(t.id), t]));
+	const menus = terms.filter((t) => t.taxonomy === "nav_menu").map((mt) => ({
+		id: num(mt.id) || null,
+		slug: mt.slug ?? "",
+		name: mt.name ?? "",
+		items: []
+	}));
+	const menuBySlug = new Map(menus.map((m) => [m.slug, m]));
+	for (const r of records.filter((x) => x.type === "nav_menu_item")) {
+		const m = r.meta;
+		const type = m._menu_item_type;
+		const object = m._menu_item_object;
+		const objectId = num(m._menu_item_object_id);
+		let target;
+		if (type === "custom") target = {
+			kind: "url",
+			url: String(m._menu_item_url ?? ""),
+			resolved: true
+		};
+		else if (type === "post_type") {
+			const p = postById.get(objectId);
+			target = {
+				kind: "post",
+				post_type: object ?? "",
+				id: objectId || null,
+				slug: p?.slug ?? null,
+				resolved: !!p
+			};
+		} else if (type === "taxonomy") {
+			const t = termByIdNum.get(objectId);
+			target = {
+				kind: "term",
+				taxonomy: object ?? "",
+				id: objectId || null,
+				slug: t?.slug ?? null,
+				resolved: !!t
+			};
+		} else if (type === "post_type_archive") target = {
+			kind: "archive",
+			post_type: object ?? "",
+			resolved: true
+		};
+		else target = {
+			kind: "unknown",
+			resolved: false
+		};
+		const parent = num(m._menu_item_menu_item_parent) || null;
+		const itemRec = {
+			id: r.id,
+			title: r.title || "slug" in target && target.slug || "",
+			order: r.menu_order,
+			parent,
+			url: m._menu_item_url || null,
+			target,
+			target_attr: m._menu_item_target || null,
+			classes: [].concat(m._menu_item_classes ?? []).filter(Boolean),
+			description: r.content,
+			status: r.status
+		};
+		const menuSlug = r.terms.find((t) => t.taxonomy === "nav_menu")?.slug;
+		const menu = menuSlug ? menuBySlug.get(menuSlug) : void 0;
+		if (menu) menu.items.push(itemRec);
+	}
+	const allMenuItemIds = new Set(menus.flatMap((m) => m.items.map((i) => i.id)));
+	for (const m of menus) for (const i of m.items) if (i.parent && !allMenuItemIds.has(i.parent)) i.parent_unresolved = true;
+	const comments = [];
+	for (const r of records) {
+		const ids = new Set(r._comments.map((c) => c.id));
+		for (const c of r._comments) comments.push({
+			...c,
+			parent_resolved: c.parent ? ids.has(c.parent) : null
+		});
+	}
+	const rawAuthors = authors.map((a) => ({
+		id: num(a.id) || null,
+		login: a.login ?? "",
+		email: a.email || null,
+		display_name: a.display_name || a.login || "",
+		first_name: a.first_name || null,
+		last_name: a.last_name || null
+	}));
+	const rawTerms = terms.filter((t) => t.taxonomy !== "nav_menu").map((t) => ({
+		id: num(t.id) || null,
+		taxonomy: t.taxonomy ?? "",
+		slug: t.slug ?? "",
+		name: t.name ?? "",
+		parent: t.parent || null,
+		parent_resolved: t.parent ? termSet.has(termKey(t.taxonomy ?? "", t.parent)) : null,
+		description: t.description || ""
+	}));
+	stats.serialized.keys = [...serializedKeySet].toSorted();
+	stats.counts = {
+		items: records.length,
+		posts: posts.length,
+		attachments: attachments.length,
+		terms: rawTerms.length,
+		authors: rawAuthors.length,
+		menus: menus.length,
+		comments: comments.length
+	};
+	return {
+		raw: {
+			version: MIGRATION_CONTRACT_VERSION,
+			provenance: {
+				kind: "wxr",
+				tool: opts?.tool ?? "@contentrain/wp-import"
+			},
+			site: {
+				url: String(site.link ?? channelText.link ?? ""),
+				title: strip(channelText.title),
+				description: strip(channelText.description) || void 0,
+				base_site_url: channelText.base_site_url,
+				base_blog_url: channelText.base_blog_url,
+				language: channelText.language ?? null,
+				generator: site.generator ?? null,
+				export_date: site.export_date ?? null,
+				wxr_version: channelText.wxr_version ?? null
+			},
+			authors: rawAuthors,
+			terms: rawTerms,
+			posts,
+			attachments,
+			menus,
+			comments
+		},
+		stats
+	};
+}
+const MIME = {
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	png: "image/png",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml",
+	mp3: "audio/mpeg",
+	mp4: "video/mp4",
+	pdf: "application/pdf"
+};
+function guessMime(u) {
+	return MIME[(u.split("?")[0]?.split(".").pop() ?? "").toLowerCase()] ?? null;
+}
+//#endregion
+//#region src/rest.ts
+const iso = (gmt) => gmt ? `${gmt}Z` : null;
+const approvedOf = (status) => status === "approved" ? "1" : status === "hold" ? "0" : status === "spam" ? "spam" : status === "trash" ? "trash" : status ?? "1";
+async function fetchRestRawIR(options) {
+	const origin = options.origin.replace(/\/$/, "");
+	const doFetch = options.fetchImpl ?? fetch;
+	const perPage = options.perPage ?? 100;
+	const warnings = [];
+	const headers = { accept: "application/json" };
+	if (options.auth) headers.authorization = `Basic ${Buffer.from(`${options.auth.user}:${options.auth.appPassword}`).toString("base64")}`;
+	const getAll = async (path) => {
+		const url = (page) => `${origin}/wp-json/wp/v2/${path}${path.includes("?") ? "&" : "?"}per_page=${perPage}&page=${page}`;
+		const first = await doFetch(url(1), { headers });
+		if (!first.ok) {
+			warnings.push(`${path}: HTTP ${first.status} — skipped`);
+			return [];
+		}
+		const totalPages = Number(first.headers.get("x-wp-totalpages") ?? "1") || 1;
+		const firstPage = await first.json();
+		if (totalPages <= 1) return firstPage;
+		const rest = await Promise.all(Array.from({ length: totalPages - 1 }, (_v, i) => doFetch(url(i + 2), { headers }).then(async (r) => r.ok ? await r.json() : [])));
+		return firstPage.concat(...rest);
+	};
+	const typesResp = await doFetch(`${origin}/wp-json/wp/v2/types`, { headers });
+	const types = typesResp.ok ? await typesResp.json() : {};
+	if (!typesResp.ok) warnings.push(`types: HTTP ${typesResp.status} — importing posts and pages only`);
+	const postTypes = Object.values(types).filter((t) => t.rest_base && !SKIP_TYPES.test(t.slug) && t.slug !== "attachment");
+	const bases = postTypes.length ? postTypes.map((t) => ({
+		slug: t.slug,
+		base: t.rest_base
+	})) : [{
+		slug: "post",
+		base: "posts"
+	}, {
+		slug: "page",
+		base: "pages"
+	}];
+	const [categories, tags, users, media, restComments, ...postLists] = await Promise.all([
+		getAll("categories"),
+		getAll("tags"),
+		getAll("users"),
+		getAll("media"),
+		getAll("comments"),
+		...bases.map((b) => getAll(b.base))
+	]);
+	const termsById = /* @__PURE__ */ new Map();
+	for (const [tax, list] of [["category", categories], ["post_tag", tags]]) for (const t of list) termsById.set(t.id, {
+		id: t.id,
+		taxonomy: tax,
+		slug: t.slug,
+		name: strip(t.name),
+		parent: t.parent ? list.find((x) => x.id === t.parent)?.slug ?? null : null,
+		parent_resolved: t.parent ? list.some((x) => x.id === t.parent) : null,
+		description: t.description ?? ""
+	});
+	const userById = new Map(users.map((u) => [u.id, u]));
+	const posts = [];
+	for (const [i, base] of bases.entries()) for (const p of postLists[i] ?? []) {
+		const termRefs = [...p.categories ?? [], ...p.tags ?? []].map((id) => {
+			const t = termsById.get(id);
+			return t ? {
+				taxonomy: t.taxonomy,
+				slug: t.slug,
+				name: t.name,
+				resolved: true
+			} : {
+				taxonomy: "category",
+				slug: String(id),
+				name: String(id),
+				resolved: false
+			};
+		});
+		const author = p.author ? userById.get(p.author)?.slug ?? null : null;
+		const meta = { ...p.meta && typeof p.meta === "object" ? p.meta : {} };
+		if (p.featured_media) meta._thumbnail_id = String(p.featured_media);
+		posts.push({
+			id: p.id,
+			type: base.slug,
+			status: p.status ?? "publish",
+			slug: p.slug,
+			title: p.title?.rendered ?? "",
+			link: p.link ?? null,
+			guid: null,
+			author,
+			date: iso(p.date_gmt),
+			modified: iso(p.modified_gmt),
+			content: p.content?.rendered ?? "",
+			excerpt: p.excerpt?.rendered ?? "",
+			parent: p.parent || null,
+			menu_order: p.menu_order ?? 0,
+			sticky: p.sticky ?? false,
+			password: null,
+			comment_status: p.comment_status ?? null,
+			ping_status: p.ping_status ?? null,
+			terms: termRefs,
+			meta
+		});
+	}
+	const attachments = media.map((m) => ({
+		id: m.id,
+		title: strip(m.title?.rendered) || m.slug,
+		slug: m.slug,
+		url: m.source_url ?? null,
+		alt: m.alt_text ?? "",
+		caption: strip(m.caption?.rendered),
+		file: m.media_details?.file ?? null,
+		image_meta: m.media_details ?? null,
+		mime: m.mime_type ?? null,
+		parent: m.post ?? null,
+		parent_resolved: m.post ? posts.some((p) => p.id === m.post) : null,
+		date: iso(m.date_gmt)
+	}));
+	const postIds = new Set(posts.map((p) => p.id));
+	const commentIds = new Set(restComments.map((c) => c.id));
+	const comments = restComments.map((c) => ({
+		id: c.id,
+		post: c.post,
+		post_type: posts.find((p) => p.id === c.post)?.type,
+		parent: c.parent || null,
+		parent_resolved: c.parent ? commentIds.has(c.parent) : null,
+		author: strip(c.author_name) || "anonymous",
+		email: null,
+		url: c.author_url || null,
+		date: iso(c.date_gmt),
+		date_gmt: c.date_gmt ?? null,
+		content: c.content?.rendered ?? "",
+		approved: approvedOf(c.status),
+		type: c.type ?? "comment",
+		user_id: c.author || null
+	}));
+	for (const c of comments) if (!postIds.has(c.post)) warnings.push(`comment ${c.id}: post ${c.post} not in fetched set`);
+	return {
+		raw: {
+			version: MIGRATION_CONTRACT_VERSION,
+			provenance: {
+				kind: options.auth ? "rest_auth" : "rest_public",
+				tool: options.tool ?? "@contentrain/wp-import"
+			},
+			site: { url: origin },
+			authors: users.map((u) => ({
+				id: u.id,
+				login: u.slug,
+				display_name: strip(u.name) || u.slug,
+				email: null
+			})),
+			terms: [...termsById.values()],
+			posts,
+			attachments,
+			comments
+		},
+		warnings
+	};
+}
+//#endregion
+//#region src/contentrain.ts
+const pick = (o, keys) => Object.fromEntries(Object.entries(o).filter(([k, v]) => keys.has(k) && v !== void 0 && v !== null && v !== ""));
+const typeModelId = (t) => t === "post" ? "posts" : t === "page" ? "pages" : t.replace(/_/g, "-");
+const domainOf = (t) => t === "post" ? "blog" : t === "page" ? "site" : "custom";
+function rawToContentrain(raw, opts) {
+	const updatedBy = opts?.updatedBy ?? "@contentrain/wp-import";
+	const locale = (raw.site.language ?? "en").split(/[-_]/)[0]?.toLowerCase() || "en";
+	const models = {};
+	const contents = {};
+	const metas = {};
+	let siteEntry = {};
+	let siteMeta = null;
+	const report = {
+		slug_rewritten: 0,
+		slug_fallback: 0,
+		title_fallback: 0,
+		meta_fields: {},
+		acf_fields: {},
+		skipped_types: [],
+		dropped_relations: 0,
+		models: {}
+	};
+	const importMeta = (status, extra = {}) => ({
+		status,
+		source: "import",
+		updated_by: updatedBy,
+		...extra
+	});
+	const mapStatus = (p) => p.status === "publish" || p.status === "inherit" ? importMeta("published") : p.status === "future" ? importMeta("draft", p.date ? { publish_at: p.date } : {}) : p.status === "pending" ? importMeta("in_review") : p.status === "trash" ? importMeta("archived") : importMeta("draft");
+	const addModel = (m) => {
+		models[m.id] = m;
+		contents[m.id] ??= {};
+		metas[m.id] ??= {};
+	};
+	const authorId = (login) => hexId(`authors:${login}`);
+	const termId = (tax, slug) => hexId(`${tax}:${slug}`);
+	const usedSlugs = /* @__PURE__ */ new Map();
+	const postSlug = (p) => {
+		let s = slugify(decodeSlug(p.slug));
+		if (!s) {
+			s = `${p.type}-${p.id}`;
+			report.slug_fallback++;
+		} else if (s !== p.slug) report.slug_rewritten++;
+		const key = `${p.type}:${s}`;
+		const n = usedSlugs.get(key) ?? 0;
+		usedSlugs.set(key, n + 1);
+		return n ? `${s}-${p.id}` : s;
+	};
+	const slugOf = /* @__PURE__ */ new Map();
+	const postEntry = /* @__PURE__ */ new Map();
+	for (const p of raw.posts) {
+		const s = postSlug(p);
+		slugOf.set(p.id, s);
+		postEntry.set(p.id, {
+			model: typeModelId(p.type),
+			ref: hexId(`${typeModelId(p.type)}:${s}`)
+		});
+	}
+	const mediaRef = (id) => raw.attachments.some((a) => a.id === id) ? hexId(`media:${id}`) : null;
+	const titleOf = (p) => {
+		const t = strip(p.title);
+		if (t) return t;
+		report.title_fallback++;
+		return slugOf.get(p.id) ?? `#${p.id}`;
+	};
+	addModel({
+		id: "authors",
+		name: "Authors",
+		kind: "collection",
+		domain: "blog",
+		i18n: false,
+		title_field: "name",
+		fields: {
+			name: {
+				type: "string",
+				required: true,
+				label: "Name",
+				order: 10
+			},
+			slug: {
+				type: "slug",
+				required: true,
+				unique: true,
+				label: "Slug",
+				order: 20
+			},
+			email: {
+				type: "email",
+				label: "Email",
+				order: 30
+			},
+			wp_id: {
+				type: "integer",
+				label: "WP user ID",
+				order: 40
+			}
+		}
+	});
+	for (const a of raw.authors) {
+		const id = authorId(slugify(a.login));
+		contents.authors[id] = pick({
+			name: strip(a.display_name),
+			slug: slugify(a.login),
+			email: a.email,
+			wp_id: a.id
+		}, new Set([
+			"name",
+			"slug",
+			"email",
+			"wp_id"
+		]));
+		metas.authors[id] = importMeta("published");
+	}
+	for (const p of raw.posts) if (p.author && !contents.authors[authorId(slugify(p.author))]) {
+		contents.authors[authorId(slugify(p.author))] = {
+			name: p.author,
+			slug: slugify(p.author)
+		};
+		metas.authors[authorId(slugify(p.author))] = importMeta("published");
+	}
+	const taxonomies = [...new Set(raw.terms.map((t) => t.taxonomy))].filter((t) => t !== "nav_menu" && t !== "post_format");
+	for (const tax of taxonomies) {
+		const mid = taxModelId(tax);
+		addModel({
+			id: mid,
+			name: mid,
+			kind: "collection",
+			domain: "blog",
+			i18n: false,
+			title_field: "name",
+			fields: {
+				name: {
+					type: "string",
+					required: true,
+					label: "Name",
+					order: 10
+				},
+				slug: {
+					type: "slug",
+					required: true,
+					unique: true,
+					label: "Slug",
+					order: 20
+				},
+				description: {
+					type: "text",
+					label: "Description",
+					order: 30
+				},
+				parent: {
+					type: "relation",
+					model: mid,
+					label: "Parent",
+					order: 40
+				},
+				wp_id: {
+					type: "integer",
+					label: "WP term ID",
+					order: 50
+				}
+			}
+		});
+		for (const t of raw.terms.filter((x) => x.taxonomy === tax)) {
+			const id = termId(tax, t.slug);
+			contents[mid][id] = pick({
+				name: strip(t.name),
+				slug: slugify(decodeSlug(t.slug)) || `term-${t.id}`,
+				description: strip(t.description),
+				parent: t.parent && t.parent_resolved ? termId(tax, t.parent) : null,
+				wp_id: t.id
+			}, new Set([
+				"name",
+				"slug",
+				"description",
+				"parent",
+				"wp_id"
+			]));
+			metas[mid][id] = importMeta("published");
+		}
+	}
+	for (const p of raw.posts) for (const t of p.terms) {
+		if (t.taxonomy === "nav_menu" || t.taxonomy === "post_format" || t.resolved) continue;
+		const mid = taxModelId(t.taxonomy);
+		if (!models[mid]) continue;
+		const id = termId(t.taxonomy, t.slug);
+		contents[mid][id] ??= {
+			name: strip(t.name),
+			slug: slugify(t.slug)
+		};
+		metas[mid][id] ??= importMeta("published");
+	}
+	addModel({
+		id: "media",
+		name: "Media",
+		kind: "collection",
+		domain: "assets",
+		i18n: false,
+		title_field: "title",
+		fields: {
+			title: {
+				type: "string",
+				required: true,
+				label: "Title",
+				order: 10
+			},
+			slug: {
+				type: "slug",
+				required: true,
+				unique: true,
+				label: "Slug",
+				order: 20
+			},
+			url: {
+				type: "url",
+				required: true,
+				label: "Source URL",
+				order: 30
+			},
+			alt: {
+				type: "string",
+				label: "Alt text",
+				order: 40
+			},
+			caption: {
+				type: "text",
+				label: "Caption",
+				order: 50
+			},
+			description: {
+				type: "text",
+				label: "Description",
+				order: 60
+			},
+			mime: {
+				type: "string",
+				label: "MIME type",
+				order: 70
+			},
+			width: {
+				type: "integer",
+				label: "Width",
+				order: 80
+			},
+			height: {
+				type: "integer",
+				label: "Height",
+				order: 90
+			},
+			file: {
+				type: "string",
+				label: "Upload path",
+				order: 100
+			},
+			parent: {
+				type: "relation",
+				model: [],
+				label: "Attached to",
+				order: 110
+			},
+			wp_id: {
+				type: "integer",
+				label: "WP attachment ID",
+				order: 120
+			},
+			uploaded_at: {
+				type: "datetime",
+				label: "Uploaded at",
+				order: 130
+			}
+		}
+	});
+	const mediaSlugs = /* @__PURE__ */ new Set();
+	for (const a of raw.attachments) {
+		const id = hexId(`media:${a.id}`);
+		let slug = slugify(decodeSlug(a.slug)) || `media-${a.id}`;
+		if (mediaSlugs.has(slug)) slug = `${slug}-${a.id}`;
+		mediaSlugs.add(slug);
+		const parent = a.parent ? postEntry.get(a.parent) ?? null : null;
+		if (a.parent && !parent) report.dropped_relations++;
+		const im = a.image_meta ?? null;
+		contents.media[id] = pick({
+			title: strip(a.title) || slug,
+			slug,
+			url: a.url,
+			alt: strip(a.alt),
+			caption: strip(a.caption),
+			description: strip(a.description),
+			mime: a.mime,
+			width: im?.width,
+			height: im?.height,
+			file: a.file,
+			parent,
+			wp_id: a.id,
+			uploaded_at: a.date
+		}, new Set([
+			"title",
+			"slug",
+			"url",
+			"alt",
+			"caption",
+			"description",
+			"mime",
+			"width",
+			"height",
+			"file",
+			"parent",
+			"wp_id",
+			"uploaded_at"
+		]));
+		metas.media[id] = importMeta("published");
+	}
+	const postTypes = [...new Set(raw.posts.map((p) => p.type))].filter((t) => {
+		if (SKIP_TYPES.test(t)) {
+			report.skipped_types.push(t);
+			return false;
+		}
+		return true;
+	});
+	const contentModelIds = postTypes.map(typeModelId);
+	models.media.fields.parent.model = contentModelIds;
+	for (const type of postTypes) {
+		const typeItems = raw.posts.filter((p) => p.type === type);
+		const mid = typeModelId(type);
+		const taxes = [...new Set(typeItems.flatMap((p) => p.terms.map((t) => t.taxonomy)))].filter((t) => models[taxModelId(t)]);
+		const { fields, order } = coreFields({
+			excerpt: typeItems.some((p) => p.excerpt),
+			body: typeItems.some((p) => p.content),
+			date: typeItems.some((p) => p.date),
+			author: typeItems.some((p) => p.author),
+			taxes,
+			cover: typeItems.some((p) => p.meta._thumbnail_id)
+		});
+		let o = order;
+		fields.wp_id = {
+			type: "integer",
+			required: true,
+			unique: true,
+			label: "WP post ID",
+			order: o += 10
+		};
+		fields.modified_at = {
+			type: "datetime",
+			label: "Modified at",
+			order: o += 10
+		};
+		fields.link = {
+			type: "url",
+			label: "Original permalink",
+			order: o += 10
+		};
+		if (typeItems.some((p) => p.parent)) fields.parent = {
+			type: "relation",
+			model: mid,
+			label: "Parent",
+			order: o += 10
+		};
+		if (typeItems.some((p) => p.menu_order)) fields.menu_order = {
+			type: "integer",
+			label: "Menu order",
+			order: o += 10
+		};
+		if (typeItems.some((p) => p.sticky)) fields.sticky = {
+			type: "boolean",
+			label: "Sticky",
+			order: o += 10
+		};
+		if (typeItems.some((p) => typeof p.meta._wp_page_template === "string" && p.meta._wp_page_template !== "default")) fields.template = {
+			type: "string",
+			label: "Page template",
+			order: o += 10
+		};
+		const formats = [...new Set(typeItems.flatMap((p) => p.terms.filter((t) => t.taxonomy === "post_format").map((t) => t.slug.replace(/^post-format-/, ""))))].toSorted();
+		if (formats.length) fields.format = {
+			type: "select",
+			options: formats,
+			label: "Post format",
+			order: o += 10
+		};
+		if (typeItems.some((p) => p.status === "private" || p.password)) fields.visibility = {
+			type: "select",
+			options: [
+				"public",
+				"private",
+				"password"
+			],
+			label: "Visibility",
+			order: o += 10
+		};
+		if (typeItems.some((p) => p.comment_status)) fields.comments_open = {
+			type: "boolean",
+			label: "Comments open",
+			order: o += 10
+		};
+		for (const p of typeItems) {
+			for (const [k, v] of Object.entries(p.meta)) {
+				if (k.startsWith("_") || fields[k] || PLUGIN_META.test(k) || k === "enclosure") continue;
+				const t = byValue(v);
+				if (t && t !== "object") {
+					fields[k] = {
+						type: t,
+						label: k,
+						order: o += 10
+					};
+					report.meta_fields[k] = t;
+				}
+			}
+			for (const [k, acf] of Object.entries(p.acf ?? {})) {
+				if (fields[k]) continue;
+				const t = byValue(acf.value) ?? "string";
+				fields[k] = {
+					type: t === "object" ? "object" : t,
+					label: k,
+					description: "ACF",
+					order: o += 10
+				};
+				report.acf_fields[k] = t;
+			}
+		}
+		addModel({
+			id: mid,
+			name: type === "post" ? "Posts" : type === "page" ? "Pages" : mid,
+			kind: "collection",
+			domain: domainOf(type),
+			i18n: false,
+			title_field: "title",
+			fields
+		});
+		for (const p of typeItems) {
+			const id = postEntry.get(p.id).ref;
+			const e = {
+				title: titleOf(p),
+				slug: slugOf.get(p.id),
+				wp_id: p.id
+			};
+			if (fields.excerpt) e.excerpt = strip(p.excerpt);
+			if (fields.body) e.body = p.content;
+			if (fields.published_at && p.date) e.published_at = p.date;
+			if (p.modified) e.modified_at = p.modified;
+			if (p.link) e.link = p.link;
+			if (fields.author && p.author) e.author = authorId(slugify(p.author));
+			for (const t of taxes) e[taxModelId(t)] = p.terms.filter((x) => x.taxonomy === t && contents[taxModelId(t)][termId(t, x.slug)]).map((x) => termId(t, x.slug));
+			if (fields.cover && p.meta._thumbnail_id) {
+				const m = mediaRef(Number(p.meta._thumbnail_id));
+				if (m) e.cover = m;
+				else report.dropped_relations++;
+			}
+			if (fields.parent && p.parent) {
+				const pe = postEntry.get(p.parent);
+				if (pe && pe.model === mid) e.parent = pe.ref;
+				else report.dropped_relations++;
+			}
+			if (fields.menu_order && p.menu_order) e.menu_order = p.menu_order;
+			if (fields.sticky) e.sticky = p.sticky ?? false;
+			if (fields.template && typeof p.meta._wp_page_template === "string" && p.meta._wp_page_template !== "default") e.template = p.meta._wp_page_template;
+			if (fields.format) {
+				const f = p.terms.find((t) => t.taxonomy === "post_format");
+				if (f) e.format = f.slug.replace(/^post-format-/, "");
+			}
+			if (fields.visibility) e.visibility = p.password ? "password" : p.status === "private" ? "private" : "public";
+			if (fields.comments_open) e.comments_open = p.comment_status === "open";
+			for (const k of Object.keys(fields)) if (k in p.meta && !(k in e) && !k.startsWith("_")) e[k] = p.meta[k];
+			for (const [k, acf] of Object.entries(p.acf ?? {})) if (fields[k] && !(k in e)) e[k] = acf.value;
+			contents[mid][id] = e;
+			metas[mid][id] = mapStatus(p);
+		}
+	}
+	const menus = raw.menus ?? [];
+	if (menus.length) {
+		addModel({
+			id: "menus",
+			name: "Menus",
+			kind: "collection",
+			domain: "site",
+			i18n: false,
+			title_field: "name",
+			fields: {
+				name: {
+					type: "string",
+					required: true,
+					label: "Name",
+					order: 10
+				},
+				slug: {
+					type: "slug",
+					required: true,
+					unique: true,
+					label: "Slug",
+					order: 20
+				},
+				items: {
+					type: "relations",
+					model: "menu-items",
+					label: "Items",
+					order: 30
+				},
+				wp_id: {
+					type: "integer",
+					label: "WP term ID",
+					order: 40
+				}
+			}
+		});
+		addModel({
+			id: "menu-items",
+			name: "Menu items",
+			kind: "collection",
+			domain: "site",
+			i18n: false,
+			title_field: "title",
+			fields: {
+				title: {
+					type: "string",
+					required: true,
+					label: "Label",
+					order: 10
+				},
+				menu: {
+					type: "relation",
+					model: "menus",
+					required: true,
+					label: "Menu",
+					order: 20
+				},
+				order: {
+					type: "integer",
+					label: "Order",
+					order: 30
+				},
+				parent: {
+					type: "relation",
+					model: "menu-items",
+					label: "Parent item",
+					order: 40
+				},
+				type: {
+					type: "select",
+					options: [
+						"custom",
+						"post_type",
+						"taxonomy",
+						"post_type_archive"
+					],
+					label: "Type",
+					order: 50
+				},
+				url: {
+					type: "url",
+					label: "URL",
+					order: 60
+				},
+				target: {
+					type: "relation",
+					model: [...contentModelIds, ...taxonomies.map(taxModelId)],
+					label: "Target",
+					order: 70
+				},
+				open_in_new_tab: {
+					type: "boolean",
+					label: "Open in new tab",
+					order: 80
+				},
+				classes: {
+					type: "array",
+					items: "string",
+					label: "CSS classes",
+					order: 90
+				},
+				description: {
+					type: "text",
+					label: "Description",
+					order: 100
+				},
+				wp_id: {
+					type: "integer",
+					label: "WP post ID",
+					order: 110
+				}
+			}
+		});
+		const itemRef = (id) => hexId(`menu-items:${id}`);
+		for (const m of menus) {
+			const mid = hexId(`menus:${m.slug}`);
+			contents.menus[mid] = {
+				name: strip(m.name),
+				slug: slugify(m.slug) || `menu-${m.id}`,
+				items: m.items.map((i) => itemRef(i.id)),
+				wp_id: m.id
+			};
+			metas.menus[mid] = importMeta("published");
+			for (const i of m.items) {
+				const e = {
+					title: strip(i.title) || i.url || `item-${i.id}`,
+					menu: mid,
+					order: i.order,
+					type: i.target.kind === "url" ? "custom" : i.target.kind === "post" ? "post_type" : i.target.kind === "term" ? "taxonomy" : i.target.kind === "archive" ? "post_type_archive" : "custom",
+					wp_id: i.id,
+					open_in_new_tab: i.target_attr === "_blank"
+				};
+				if (i.parent && !i.parent_unresolved) e.parent = itemRef(i.parent);
+				if (i.target.kind === "url" && i.url) e.url = i.url;
+				if (i.target.kind === "post" && i.target.resolved && i.target.id != null) {
+					const pe = postEntry.get(i.target.id);
+					if (pe) e.target = pe;
+					else report.dropped_relations++;
+				}
+				if (i.target.kind === "term" && i.target.resolved && i.target.slug && models[taxModelId(i.target.taxonomy)]) e.target = {
+					model: taxModelId(i.target.taxonomy),
+					ref: termId(i.target.taxonomy, i.target.slug)
+				};
+				if (i.classes?.length) e.classes = i.classes;
+				if (i.description) e.description = strip(i.description);
+				contents["menu-items"][itemRef(i.id)] = e;
+				metas["menu-items"][itemRef(i.id)] = importMeta(i.status === "publish" ? "published" : "draft");
+			}
+		}
+	}
+	const comments = raw.comments ?? [];
+	if (comments.length) {
+		addModel({
+			id: "comments",
+			name: "Comments",
+			kind: "collection",
+			domain: "blog",
+			i18n: false,
+			title_field: "author",
+			fields: {
+				author: {
+					type: "string",
+					required: true,
+					label: "Author",
+					order: 10
+				},
+				email: {
+					type: "email",
+					label: "Email",
+					order: 20
+				},
+				url: {
+					type: "url",
+					label: "Website",
+					order: 30
+				},
+				body: {
+					type: "richtext",
+					label: "Body",
+					order: 40
+				},
+				published_at: {
+					type: "datetime",
+					label: "Date",
+					order: 50
+				},
+				post: {
+					type: "relation",
+					model: contentModelIds,
+					required: true,
+					label: "Post",
+					order: 60
+				},
+				parent: {
+					type: "relation",
+					model: "comments",
+					label: "In reply to",
+					order: 70
+				},
+				type: {
+					type: "string",
+					label: "Type",
+					order: 80
+				},
+				user: {
+					type: "relation",
+					model: "authors",
+					label: "User",
+					order: 90
+				},
+				wp_id: {
+					type: "integer",
+					label: "WP comment ID",
+					order: 100
+				}
+			}
+		});
+		const cRef = (id) => hexId(`comments:${id}`);
+		const userById = new Map(raw.authors.filter((a) => a.id != null).map((a) => [a.id, authorId(slugify(a.login))]));
+		for (const c of comments) {
+			const post = postEntry.get(c.post);
+			if (!post) {
+				report.dropped_relations++;
+				continue;
+			}
+			contents.comments[cRef(c.id)] = pick({
+				author: strip(c.author) || "anonymous",
+				email: c.email,
+				url: c.url,
+				body: c.content,
+				published_at: c.date,
+				post,
+				parent: c.parent && c.parent_resolved ? cRef(c.parent) : null,
+				type: c.type,
+				user: c.user_id ? userById.get(c.user_id) : null,
+				wp_id: c.id
+			}, new Set([
+				"author",
+				"email",
+				"url",
+				"body",
+				"published_at",
+				"post",
+				"parent",
+				"type",
+				"user",
+				"wp_id"
+			]));
+			metas.comments[cRef(c.id)] = importMeta(c.approved === "1" ? "published" : c.approved === "spam" || c.approved === "trash" ? "archived" : "in_review");
+		}
+	}
+	addModel({
+		id: "site",
+		name: "Site",
+		kind: "singleton",
+		domain: "site",
+		i18n: false,
+		title_field: "title",
+		fields: {
+			title: {
+				type: "string",
+				required: true,
+				label: "Site title",
+				order: 10
+			},
+			tagline: {
+				type: "string",
+				label: "Tagline",
+				order: 20
+			},
+			url: {
+				type: "url",
+				label: "URL",
+				order: 30
+			},
+			language: {
+				type: "string",
+				label: "Language",
+				order: 40
+			}
+		}
+	});
+	siteEntry = pick({
+		title: strip(raw.site.title) || "Site",
+		tagline: raw.site.description,
+		url: raw.site.url,
+		language: raw.site.language
+	}, new Set([
+		"title",
+		"tagline",
+		"url",
+		"language"
+	]));
+	siteMeta = importMeta("published");
+	const vocabTerms = {};
+	for (const m of menus) for (const i of m.items) {
+		const k = slugify(strip(i.title));
+		if (k && !vocabTerms[k]) vocabTerms[k] = { [locale]: strip(i.title) };
+	}
+	const files = {};
+	const domains = [...new Set(Object.values(models).map((m) => m.domain))].toSorted();
+	for (const m of Object.values(models)) {
+		files[`.contentrain/models/${m.id}.json`] = canon(m);
+		const content = m.kind === "singleton" ? siteEntry : contents[m.id];
+		const meta = m.kind === "singleton" ? siteMeta : metas[m.id];
+		files[`.contentrain/content/${m.domain}/${m.id}/data.json`] = canon(content);
+		files[`.contentrain/meta/${m.id}/${locale}.json`] = canon(meta);
+		report.models[m.id] = {
+			kind: m.kind,
+			domain: m.domain,
+			fields: Object.keys(m.fields ?? {}).length,
+			entries: m.kind === "singleton" ? 1 : Object.keys(contents[m.id]).length
+		};
+	}
+	files[".contentrain/config.json"] = canon({
+		version: 1,
+		stack: "astro",
+		platform: "web",
+		workflow: "review",
+		locales: {
+			default: locale,
+			supported: [locale]
+		},
+		domains
+	});
+	files[".contentrain/vocabulary.json"] = canon({
+		version: 1,
+		terms: vocabTerms
+	});
+	const entrySourceMap = {};
+	for (const [wpId, ref] of postEntry) entrySourceMap[String(wpId)] = {
+		model_id: ref.model,
+		entry_id: ref.ref,
+		locale
+	};
+	files["import-report.json"] = canon(report);
+	return {
+		files,
+		entry_source_map: entrySourceMap,
+		report
+	};
+}
+//#endregion
+//#region src/comments.ts
+function buildCommentsExport(raw, entries, opts) {
+	const threadsClosed = raw.posts.filter((p) => p.comment_status && p.comment_status !== "open").map((p) => p.id);
+	return {
+		version: MIGRATION_CONTRACT_VERSION,
+		format: COMMENTS_EXPORT_FORMAT,
+		source: raw.provenance,
+		site_url: raw.site.url || void 0,
+		generated_at: opts?.generated_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+		entries,
+		threads_closed: threadsClosed.length ? threadsClosed : void 0,
+		comments: raw.comments ?? []
+	};
+}
+/** Handoff summary for the export: counts + closed threads + what could not be addressed. */
+function summarizeComments(exp) {
+	const byStatus = {};
+	const byType = {};
+	const unresolved = [];
+	for (const c of exp.comments) {
+		byStatus[c.approved ?? "1"] = (byStatus[c.approved ?? "1"] ?? 0) + 1;
+		byType[c.type ?? "comment"] = (byType[c.type ?? "comment"] ?? 0) + 1;
+		if (!exp.entries[String(c.post)]) unresolved.push({
+			comment_id: c.id,
+			post: c.post,
+			reason: "post has no entry mapping"
+		});
+	}
+	return {
+		total: exp.comments.length,
+		by_status: byStatus,
+		types: byType,
+		export: { format: exp.format },
+		threads_closed: exp.threads_closed,
+		unresolved: unresolved.length ? unresolved : void 0
+	};
+}
+//#endregion
+export { buildCommentsExport, canon, fetchRestRawIR, hexId, looksSerialized, parseWxr, phpUnserialize, rawToContentrain, slugify, strip, summarizeComments, taxModelId, tryUnserialize };
+
+//# sourceMappingURL=index.mjs.map