@contentrain/wp-import 0.7.0 → 0.9.0

package/dist/index.mjs

@@ -525,6 +525,7 @@ async function parseWxr(input, opts) {
 		mime: guessMime(r.attachment_url ?? r.guid ?? ""),
 		parent: r.parent,
 		parent_resolved: r.parent ? byId.has(r.parent) : null,
+		link: !r.parent || byId.get(r.parent)?.status === "publish" && !byId.get(r.parent)?.password ? r.link || null : null,
 		author: r.author,
 		date: r.date,
 		status: r.status,
@@ -675,6 +676,479 @@ function guessMime(u) {
 	return MIME[(u.split("?")[0]?.split(".").pop() ?? "").toLowerCase()] ?? null;
 }
 //#endregion
+//#region src/acf.ts
+/** ACF types that never carry content (layout) or must never be read (secrets). */
+const ACF_LAYOUT_TYPES = new Set([
+	"tab",
+	"accordion",
+	"message"
+]);
+const ACF_SECRET_TYPES = new Set(["password"]);
+/**
+* ACF type → Contentrain type, for types whose value maps without a lookup.
+* `select` with `multiple` and `checkbox` are arrays of their options; see `acfFieldDef`.
+*/
+const ACF_SCALAR_TYPES = {
+	text: "string",
+	textarea: "text",
+	wysiwyg: "richtext",
+	email: "email",
+	url: "url",
+	oembed: "url",
+	number: "number",
+	range: "number",
+	true_false: "boolean",
+	date_picker: "date",
+	date_time_picker: "datetime",
+	time_picker: "string",
+	color_picker: "color",
+	icon_picker: "icon",
+	select: "select",
+	radio: "select",
+	button_group: "select",
+	image: "image",
+	file: "file"
+};
+const ACF_REFERENCE_TYPES = {
+	post_object: "post",
+	relationship: "post",
+	taxonomy: "term",
+	user: "user",
+	gallery: "media",
+	page_link: "address"
+};
+/**
+* Names that mean a secret whatever the field's type, for sources that do not state the type: whole words
+* of the name (`user_pass`, `apiKey`, `client-secret`), so `passage_text` or `compass` stay content.
+*/
+const SECRET_NAME = /(?:^|_)(?:pass(?:word|wd)?|secret|token|api_?key|private_?key|credentials?)(?:_|$)/i;
+const secretName = (name) => SECRET_NAME.test(name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/-/g, "_"));
+/** Whether a field must never be read: a secret by type, or — when the type is unknown — by name. */
+function acfIsSecret(name, type) {
+	if (type) return ACF_SECRET_TYPES.has(type);
+	return secretName(name);
+}
+const isRecord = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const SOURCE = "_source";
+/** The ACF type SCF states for a sub-field of a row or group (`<name>_source.type`). */
+const statedType = (row, k) => {
+	const s = row[`${k}${SOURCE}`];
+	return isRecord(s) && typeof s.type === "string" ? s.type : void 0;
+};
+/** A sub-field that carries nothing to keep: a secret (stated, or by name) or a layout field. */
+const droppedKey = (row, k) => {
+	const t = statedType(row, k);
+	return t !== void 0 && ACF_LAYOUT_TYPES.has(t) || acfIsSecret(k, t);
+};
+/**
+* An ACF value with every secret sub-field removed, at any depth: repeater rows, groups, flexible layouts.
+* A sub-field's `_source` keeps only its type and label — its `formatted_value` repeats the value.
+*/
+function acfScrub(value, secret = /* @__PURE__ */ new Set()) {
+	if (Array.isArray(value)) {
+		const rows = value.filter(isRecord);
+		const shared = new Set([...secret, ...rows.flatMap((r) => Object.keys(r).filter((k) => !k.endsWith(SOURCE) && droppedKey(r, k)))]);
+		return value.map((v) => acfScrub(v, shared));
+	}
+	if (!isRecord(value)) return value;
+	const gone = (k) => secret.has(k) || droppedKey(value, k);
+	const out = {};
+	for (const [k, v] of Object.entries(value)) {
+		if (k.endsWith(SOURCE) && k.length > 7) {
+			if (gone(k.slice(0, -7)) || !isRecord(v)) continue;
+			out[k] = {
+				...typeof v.type === "string" ? { type: v.type } : {},
+				...typeof v.label === "string" ? { label: v.label } : {}
+			};
+			continue;
+		}
+		if (gone(k)) continue;
+		out[k] = acfScrub(v);
+	}
+	return out;
+}
+/** ACF's image/file array (`return_format: array`): `{ ID, url, filename, … }`. */
+const isAttachment = (v) => isRecord(v) && typeof v.url === "string" && ("ID" in v || "id" in v) && ("filename" in v || "mime_type" in v);
+const isLink = (v) => isRecord(v) && typeof v.url === "string" && "title" in v && "target" in v && Object.keys(v).length <= 3;
+const isMap = (v) => isRecord(v) && typeof v.lat === "number" && typeof v.lng === "number";
+/** A date picker's stored value (`Ymd`) → ISO date. */
+const ymd = (v) => typeof v === "string" && /^\d{8}$/.test(v) ? `${v.slice(0, 4)}-${v.slice(4, 6)}-${v.slice(6, 8)}` : null;
+/** `Y-m-d H:i:s` → ISO local datetime (site time: WordPress stores it without a zone). */
+const dt = (v) => typeof v === "string" && /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(v) ? v.replace(" ", "T") : null;
+const pad = (n) => String(Math.floor(n)).padStart(2, "0");
+/** Minutes east of UTC → `+03:00`. */
+const offsetText = (minutes) => `${minutes < 0 ? "-" : "+"}${pad(Math.abs(minutes) / 60)}:${pad(Math.abs(minutes) % 60)}`;
+/** The offset of an IANA zone at a wall-clock time there (DST included), in minutes east of UTC; `null` for an unknown zone. */
+function zoneOffset(local, timeZone) {
+	let fmt;
+	try {
+		fmt = new Intl.DateTimeFormat("en-US", {
+			timeZone,
+			hourCycle: "h23",
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			second: "2-digit"
+		});
+	} catch {
+		return null;
+	}
+	const wall = Date.parse(`${local}Z`);
+	const at = (utc) => {
+		const p = Object.fromEntries(fmt.formatToParts(new Date(utc)).map((x) => [x.type, x.value]));
+		return (Date.UTC(Number(p.year), Number(p.month) - 1, Number(p.day), Number(p.hour), Number(p.minute), Number(p.second)) - utc) / 6e4;
+	};
+	return at(wall - at(wall) * 6e4);
+}
+/** A local ISO datetime with the site's offset for that moment; the local value when the site's zone is unknown. */
+function zonedDateTime(local, zone = {}) {
+	const minutes = (zone.timeZone ? zoneOffset(local, zone.timeZone) : null) ?? (typeof zone.gmtOffset === "number" && Number.isFinite(zone.gmtOffset) ? Math.round(zone.gmtOffset * 60) : null);
+	return minutes === null ? {
+		value: local,
+		zoned: false
+	} : {
+		value: `${local}${offsetText(minutes)}`,
+		zoned: true
+	};
+}
+const LINK_FIELDS = {
+	url: { type: "url" },
+	title: { type: "string" },
+	target: { type: "string" }
+};
+const MAP_FIELDS = {
+	address: { type: "string" },
+	lat: { type: "decimal" },
+	lng: { type: "decimal" },
+	zoom: { type: "integer" }
+};
+/** Contentrain type of a sub-value whose ACF type is not stated (a repeater row, a group member). */
+function inferDef(value) {
+	if (value === null || value === void 0 || value === "") return null;
+	if (isAttachment(value)) return { type: /\.(jpe?g|png|gif|webp|avif|svg)(\?|$)/i.test(value.url) ? "image" : "file" };
+	if (isLink(value)) return {
+		type: "object",
+		fields: LINK_FIELDS
+	};
+	if (isMap(value)) return {
+		type: "object",
+		fields: MAP_FIELDS
+	};
+	if (Array.isArray(value)) {
+		if (value.every(isRecord)) return {
+			type: "array",
+			items: {
+				type: "object",
+				fields: rowFields(value)
+			}
+		};
+		const item = value.map(inferDef).find(Boolean);
+		return {
+			type: "array",
+			items: item?.type === "object" ? item : item?.type ?? "string"
+		};
+	}
+	if (isRecord(value)) return {
+		type: "object",
+		fields: rowFields([value])
+	};
+	if (ymd(value)) return { type: "date" };
+	const t = byValue(value);
+	return t ? { type: t } : null;
+}
+/**
+* The union of the fields every row states; a name typed two ways falls back to `string`. A sub-field whose ACF
+* type the row states (SCF's `<name>_source`) is typed by the table like a top-level field; a reference inside a
+* row is not resolved, so it — and any sub-field without a stated type — is typed from its value.
+*/
+function rowFields(rows) {
+	const out = {};
+	for (const row of rows) for (const [k, v] of Object.entries(row)) {
+		if (k.endsWith(SOURCE) || droppedKey(row, k)) continue;
+		const stated = statedType(row, k);
+		const source = row[`${k}${SOURCE}`];
+		const label = isRecord(source) && typeof source.label === "string" ? source.label : void 0;
+		const d = stated && !ACF_REFERENCE_TYPES[stated] ? acfFieldDef(k, v, {
+			type: stated,
+			...label ? { label } : {}
+		}) : inferDef(v);
+		if (!d) continue;
+		const seen = out[k];
+		if (!seen) out[k] = d;
+		else if (seen.type !== d.type) out[k] = { type: "string" };
+	}
+	return out;
+}
+/** A value in the shape its field definition promises; `undefined` = nothing to store. */
+function acfValue(def, value, ctx = {}) {
+	if (value === null || value === void 0 || value === "" || Array.isArray(value) && !value.length) return void 0;
+	switch (def.type) {
+		case "image":
+		case "file":
+		case "video": return isAttachment(value) ? value.url : typeof value === "string" ? value : void 0;
+		case "date": return ymd(value) ?? (typeof value === "string" ? value : void 0);
+		case "datetime": {
+			const local = dt(value);
+			if (!local) return typeof value === "string" ? value : void 0;
+			const out = zonedDateTime(local, ctx);
+			if (!out.zoned) ctx.unzoned?.(out.value);
+			return out.value;
+		}
+		case "boolean": return value === true || value === 1 || value === "1";
+		case "number":
+		case "integer":
+		case "decimal": return typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value)) ? Number(value) : void 0;
+		case "icon": return isRecord(value) && typeof value.value === "string" ? value.value : typeof value === "string" ? value : void 0;
+		case "object": {
+			if (!isRecord(value)) return void 0;
+			const out = {};
+			for (const [k, sub] of Object.entries(def.fields ?? {})) {
+				if (droppedKey(value, k)) continue;
+				const v = acfValue(sub, value[k], ctx);
+				if (v !== void 0) out[k] = v;
+			}
+			return Object.keys(out).length ? out : void 0;
+		}
+		case "array": {
+			if (!Array.isArray(value)) return void 0;
+			const item = typeof def.items === "string" ? { type: def.items } : def.items ?? { type: "string" };
+			const out = value.map((v) => acfValue(item, v, ctx)).filter((v) => v !== void 0);
+			return out.length ? out : void 0;
+		}
+		case "select": {
+			const v = typeof value === "string" ? value : typeof value === "number" ? String(value) : void 0;
+			if (v !== void 0 && def.options?.length && !def.options.includes(v)) {
+				ctx.dropped?.(v, def.options);
+				return;
+			}
+			return v;
+		}
+		case "richtext":
+		case "text":
+		case "string":
+		case "url":
+		case "email":
+		case "color": return typeof value === "string" ? value : typeof value === "number" ? String(value) : void 0;
+		default: return value;
+	}
+}
+/**
+* Field definition for one ACF field value, or `null` when it carries no content, is a secret, or is a
+* reference (the caller resolves those: see `ACF_REFERENCE_TYPES`).
+*/
+function acfFieldDef(name, value, stated = {}) {
+	const t = stated.type;
+	if (t && (ACF_LAYOUT_TYPES.has(t) || ACF_REFERENCE_TYPES[t])) return null;
+	if (acfIsSecret(name, t)) return null;
+	const label = stated.label ? strip(stated.label) : void 0;
+	const withLabel = (d) => label ? {
+		...d,
+		label
+	} : d;
+	if (!t) {
+		const inferred = inferDef(value);
+		return inferred ? withLabel({
+			...inferred,
+			description: "ACF (type inferred from the value)"
+		}) : null;
+	}
+	const choices = stated.choices?.length ? stated.choices : void 0;
+	if (t === "checkbox" || t === "select" && (stated.multiple || Array.isArray(value))) return withLabel({
+		type: "array",
+		items: choices ? {
+			type: "select",
+			options: choices
+		} : "string"
+	});
+	if (ACF_SCALAR_TYPES[t]) {
+		const type = ACF_SCALAR_TYPES[t];
+		if (type === "select") return withLabel(choices ? {
+			type,
+			options: choices
+		} : { type: "string" });
+		return withLabel({ type });
+	}
+	if (t === "link") return withLabel({
+		type: "object",
+		fields: LINK_FIELDS
+	});
+	if (t === "google_map") return withLabel({
+		type: "object",
+		fields: MAP_FIELDS
+	});
+	if (t === "group") return withLabel({
+		type: "object",
+		fields: rowFields(isRecord(value) ? [value] : [])
+	});
+	if (t === "repeater") return withLabel({
+		type: "array",
+		items: {
+			type: "object",
+			fields: rowFields(Array.isArray(value) ? value.filter(isRecord) : [])
+		}
+	});
+	if (t === "flexible_content") {
+		const rows = Array.isArray(value) ? value.filter(isRecord) : [];
+		const fields = rowFields(rows.map(({ acf_fc_layout: _l, ...rest }) => rest));
+		return withLabel({
+			type: "array",
+			items: {
+				type: "object",
+				fields: {
+					layout: {
+						type: "select",
+						options: [...new Set(rows.map((r) => String(r.acf_fc_layout ?? "")).filter(Boolean))].toSorted(),
+						required: true
+					},
+					...fields
+				}
+			}
+		});
+	}
+	const inferred = inferDef(value);
+	return inferred ? withLabel({
+		...inferred,
+		description: `ACF ${t} (type inferred from the value)`
+	}) : null;
+}
+/** Merge two definitions of the same field seen on different entries (union of object fields and options). */
+function mergeFieldDef(a, b) {
+	if (a.type !== b.type) return a;
+	const out = { ...a };
+	if (a.options || b.options) out.options = [...new Set([...a.options ?? [], ...b.options ?? []])].toSorted();
+	if (a.fields || b.fields) {
+		const fields = { ...a.fields };
+		for (const [k, d] of Object.entries(b.fields ?? {})) fields[k] = fields[k] ? mergeFieldDef(fields[k], d) : d;
+		out.fields = fields;
+	}
+	if (typeof a.items === "object" && typeof b.items === "object") out.items = mergeFieldDef(a.items, b.items);
+	return out;
+}
+/** Flexible content rows keep their layout name under `layout`. */
+function acfRows(value) {
+	return Array.isArray(value) ? value.map((r) => isRecord(r) && "acf_fc_layout" in r ? (({ acf_fc_layout, ...rest }) => ({
+		layout: acf_fc_layout,
+		...rest
+	}))(r) : r) : value;
+}
+//#endregion
+//#region src/rest-redirects.ts
+/** Redirection's own defaults, under a site that states none. */
+const DEFAULTS = {
+	flag_query: "exact",
+	flag_case: false,
+	flag_trailing: false
+};
+const MODULES = {
+	2: "apache",
+	3: "nginx"
+};
+/** Codes that say an address is gone: served as that answer, with no target. */
+const GONE = new Set([410, 451]);
+/** Redirection's query modes; `exactorder` (the same parameters in the same order) is read as `exact`. */
+const QUERY = {
+	exact: "exact",
+	exactorder: "exact",
+	ignore: "ignore",
+	pass: "pass"
+};
+/** The flags one layer states, as Redirection accepts them: a known query mode, a true boolean (not `"1"`). */
+const valid = (f) => ({
+	...typeof f?.flag_query === "string" && f.flag_query in QUERY ? { flag_query: f.flag_query } : {},
+	...typeof f?.flag_case === "boolean" ? { flag_case: f.flag_case } : {},
+	...typeof f?.flag_trailing === "boolean" ? { flag_trailing: f.flag_trailing } : {}
+});
+/** By id as bytes, as the Bridge sorts (`strcmp`). */
+const order = (a, b) => (a.id ?? "") < (b.id ?? "") ? -1 : (a.id ?? "") > (b.id ?? "") ? 1 : 0;
+const on = (x) => x.enabled ?? (x.status === void 0 || x.status === "enabled");
+/** Same-site targets become root-relative, like every `from`; other hosts stay absolute (as the Bridge does). */
+function relative(url, origin) {
+	try {
+		const home = new URL(origin);
+		const u = new URL(url, `${origin}/`);
+		if (u.host.toLowerCase() !== home.host.toLowerCase()) return url;
+		return `${u.pathname}${u.search}${u.hash}`;
+	} catch {
+		return url;
+	}
+}
+/**
+* Redirection's rules and groups → the rules the site serves and the ones it does not, sorted by id.
+* A rule's query, case and trailing-slash modes are what Redirection applies to it: its own flags, else the site's
+* (`options`), else the plugin's defaults. Without `options` (not readable) only a rule's own flags are stated.
+*/
+function redirectionRules(items, groups, origin, options) {
+	const site = options ? {
+		...DEFAULTS,
+		...valid(options)
+	} : {};
+	const byId = new Map(groups.map((g) => [g.id, g]));
+	const redirects = [];
+	const excluded = [];
+	for (const item of items) {
+		const group = item.group_id === void 0 ? void 0 : byId.get(item.group_id);
+		const code = Number(item.action_code ?? 301);
+		const data = item.action_data;
+		const target = typeof data === "string" ? data : data?.url ?? "";
+		const own = item.match_data?.source ?? {};
+		const flags = {
+			...site,
+			...valid(own)
+		};
+		const rule = {
+			id: `redirection:${item.id}`,
+			from: item.url ?? "",
+			source: "redirection",
+			match: "url",
+			regex: item.regex === true || own.flag_regex === true
+		};
+		const served = group?.module_id !== void 0 ? MODULES[group.module_id] : void 0;
+		if (served) rule.served_by = served;
+		if (rule.regex) rule.query = "exact";
+		else if (typeof flags.flag_query === "string") rule.query = QUERY[flags.flag_query];
+		if (typeof flags.flag_case === "boolean") rule.case_insensitive = flags.flag_case;
+		if (typeof flags.flag_trailing === "boolean") rule.trailing_slash = flags.flag_trailing ? "ignore" : "exact";
+		const matchType = item.match_type ?? "url";
+		const actionType = item.action_type ?? "url";
+		if (!on(item) || group && !on(group)) excluded.push({
+			...rule,
+			reason: "disabled"
+		});
+		else if (actionType === "error" && GONE.has(code) && matchType === "url") redirects.push({
+			...rule,
+			to: "",
+			status: code
+		});
+		else if (actionType !== "url") excluded.push({
+			...rule,
+			status: code,
+			reason: `not-a-redirect:${actionType}`
+		});
+		else if (matchType !== "url") excluded.push({
+			...rule,
+			match: matchType,
+			status: code,
+			...matchType === "login" ? { condition: data ?? null } : {},
+			reason: `conditional-match:${matchType}`
+		});
+		else {
+			const move = code >= 300 && code < 400;
+			redirects.push({
+				...rule,
+				to: relative(target, origin),
+				status: move ? code : 301,
+				...move ? {} : { status_note: `source status ${code} is not a redirect code; 301 assumed` }
+			});
+		}
+	}
+	return {
+		redirects: redirects.toSorted(order),
+		excluded: excluded.toSorted(order)
+	};
+}
+//#endregion
 //#region src/rest-menus.ts
 const targetOf = (kind, object, id, url, ctx) => {
 	const objectId = id && id > 0 ? id : null;
@@ -713,6 +1187,12 @@ const targetOf = (kind, object, id, url, ctx) => {
 		resolved: false
 	};
 };
+/** The public address of the post or term a target names, when it is one this import proved public. */
+const publicLink = (target, ctx) => {
+	if (!target.resolved || !("id" in target) || !target.id) return void 0;
+	if (target.kind === "post") return ctx.postLink?.(target.id);
+	if (target.kind === "term") return ctx.termLink?.(target.taxonomy, target.id);
+};
 /**
 * Items that are left out: a draft item, or one whose post target is not proven visible. Their children move up
 * to the nearest kept ancestor, as WordPress's walker shows them.
@@ -733,12 +1213,35 @@ function hiddenItems(items, drop) {
 		lift
 	};
 }
+/** A host without case or a leading `www.`: example.com and www.example.com are one site (as the Bridge reads it). */
+const bareHost = (u) => u.hostname.toLowerCase().replace(/^www\./, "");
+/**
+* The post a plain permalink names (`/?page_id=14`, `/?p=14`) on this site, `www.` or not: a custom link typed by
+* hand carries no post id, but it points at a post all the same, and its label is often that post's title.
+*/
+function plainPostId(url, origin) {
+	if (!url || !url.includes("?")) return void 0;
+	try {
+		const u = new URL(url, `${origin}/`);
+		if (bareHost(u) !== bareHost(new URL(origin))) return void 0;
+		const id = Number(u.searchParams.get("page_id") ?? u.searchParams.get("p"));
+		return Number.isSafeInteger(id) && id > 0 ? id : void 0;
+	} catch {
+		return;
+	}
+}
 /** Classic menus and their items; each menu names the theme locations it is assigned to. `dropped` counts left-out items. */
 function classicMenus(menus, items, ctx, dropped = { count: 0 }) {
 	const out = [];
 	for (const m of [...menus].toSorted((a, b) => a.id - b.id)) {
 		const all = items.filter((i) => i.menus === m.id).toSorted((a, b) => (a.menu_order ?? 0) - (b.menu_order ?? 0) || a.id - b.id);
-		const { gone, lift } = hiddenItems(all, (i) => (i.status ?? "publish") !== "publish" || i.type === "post_type" && !(i.object_id && ctx.postSlug(i.object_id)));
+		const hidden = (i) => {
+			if ((i.status ?? "publish") !== "publish") return true;
+			if (i.type === "post_type") return !(i.object_id && ctx.postSlug(i.object_id));
+			const id = plainPostId(i.url, ctx.origin);
+			return id !== void 0 && !ctx.postSlug(id);
+		};
+		const { gone, lift } = hiddenItems(all, hidden);
 		dropped.count += gone.size;
 		const own = all.filter((i) => !gone.has(i.id));
 		const ids = new Set(own.map((i) => i.id));
@@ -747,13 +1250,15 @@ function classicMenus(menus, items, ctx, dropped = { count: 0 }) {
 			slug: m.slug ?? "",
 			name: strip(m.name ?? m.slug ?? ""),
 			items: own.map((i) => {
+				const target = targetOf(i.type, i.object, i.object_id, i.url, ctx);
+				const typed = target.kind === "url" ? plainPostId(i.url, ctx.origin) : void 0;
 				const item = {
 					id: i.id,
 					title: i.title?.raw || i.title?.rendered || "",
 					order: i.menu_order ?? 0,
 					parent: lift(i.parent || null),
-					url: i.url || null,
-					target: targetOf(i.type, i.object, i.object_id, i.url, ctx),
+					url: publicLink(target, ctx) ?? (typed !== void 0 ? ctx.postLink?.(typed) : void 0) ?? (i.url || null),
+					target,
 					target_attr: i.target || null,
 					classes: (i.classes ?? []).filter(Boolean),
 					description: i.description ?? "",
@@ -805,6 +1310,7 @@ function parseBlocks(content) {
 const str = (v) => typeof v === "string" && v ? v : void 0;
 const absolute = (url, origin) => {
 	if (!url) return void 0;
+	if (url.startsWith("#")) return url;
 	try {
 		return new URL(url, `${origin}/`).href;
 	} catch {
@@ -822,17 +1328,22 @@ const KIND = {
 * published pages it lists; a home link points at `/`. Other blocks (search, social icons, spacers) are not links.
 */
 function navigationItems(content, ctx, nextId, dropped = { count: 0 }) {
+	return blockItems(parseBlocks(content), ctx, nextId, dropped);
+}
+/** Menu items of navigation blocks already parsed (a `wp_navigation` body, or an inline navigation's links). */
+function blockItems(tree, ctx, nextId, dropped) {
 	const items = [];
 	const push = (b, parent) => {
 		const id = nextId();
 		const url = absolute(b.url, ctx.origin);
+		const target = targetOf(b.kind, b.object, b.id, url, ctx);
 		items.push({
 			id,
 			title: b.title,
 			order: items.length + 1,
 			parent,
-			url: url ?? null,
-			target: targetOf(b.kind, b.object, b.id, url, ctx),
+			url: publicLink(target, ctx) ?? (b.typed !== void 0 ? ctx.postLink?.(b.typed) : void 0) ?? url ?? null,
+			target,
 			target_attr: b.newTab ? "_blank" : null,
 			classes: (b.className ?? "").split(/\s+/).filter(Boolean),
 			description: b.description ?? "",
@@ -859,7 +1370,8 @@ function navigationItems(content, ctx, nextId, dropped = { count: 0 }) {
 			if (b.name === "core/navigation-link" || b.name === "core/navigation-submenu") {
 				const kind = KIND[str(a.kind) ?? ""] ?? (str(a.type) === "category" || str(a.type) === "tag" || str(a.type) === "post_tag" ? "taxonomy" : a.id ? "post_type" : "custom");
 				const object = kind === "taxonomy" && str(a.type) === "tag" ? "post_tag" : str(a.type);
-				if (kind === "post_type" && typeof a.id === "number" && !ctx.postSlug(a.id)) {
+				const postId = kind === "post_type" && typeof a.id === "number" ? a.id : kind === "custom" ? plainPostId(str(a.url), ctx.origin) : void 0;
+				if (postId !== void 0 && !ctx.postSlug(postId)) {
 					dropped.count++;
 					walk(b.children, parent);
 					continue;
@@ -870,6 +1382,7 @@ function navigationItems(content, ctx, nextId, dropped = { count: 0 }) {
 					kind,
 					object,
 					id: typeof a.id === "number" ? a.id : void 0,
+					typed: kind === "custom" ? postId : void 0,
 					newTab: a.opensInNewTab === true,
 					className: str(a.className),
 					description: str(a.description)
@@ -884,15 +1397,94 @@ function navigationItems(content, ctx, nextId, dropped = { count: 0 }) {
 			else walk(b.children, parent);
 		}
 	};
-	walk(parseBlocks(content), null);
+	walk(tree, null);
 	return items;
 }
+/** Template-part slugs the templates use, at any depth (a part inside a group, a part inside a part is not followed). */
+function partSlugs(blocks, out = /* @__PURE__ */ new Set()) {
+	for (const b of blocks) {
+		if (b.name === "core/template-part" && typeof b.attrs.slug === "string") out.add(b.attrs.slug);
+		partSlugs(b.children, out);
+	}
+	return out;
+}
+/**
+* The template parts a page can show: those a template references. Without the templates (not readable), the
+* part named after its area (`header`, `footer`) — what a theme's templates use unless they say otherwise.
+* Parts without a slug (older callers) all count.
+*/
+function usedParts(parts, templates = []) {
+	const used = /* @__PURE__ */ new Set();
+	for (const t of templates) if (t.content?.raw) partSlugs(parseBlocks(t.content.raw), used);
+	return parts.filter((p) => !p.slug || (used.size ? used.has(p.slug) : p.slug === p.area));
+}
+const AREA_ORDER = ["header", "footer"];
+const areaOf = (p) => p.area && p.area !== "uncategorized" ? p.area : void 0;
+/**
+* A part's blocks with the parts it holds in their place (a header holding a `navigation` part), each part once:
+* what the part shows, in its area.
+*/
+function partTree(part, all) {
+	const bySlug = new Map(all.filter((p) => p.slug).map((p) => [p.slug, p]));
+	const seen = new Set(part.slug ? [part.slug] : []);
+	const expand = (blocks) => blocks.flatMap((b) => {
+		if (b.name === "core/template-part") {
+			const inner = typeof b.attrs.slug === "string" ? bySlug.get(b.attrs.slug) : void 0;
+			if (!inner?.content?.raw || seen.has(inner.slug)) return [];
+			seen.add(inner.slug);
+			return expand(parseBlocks(inner.content.raw));
+		}
+		return [{
+			...b,
+			children: expand(b.children)
+		}];
+	});
+	return expand(parseBlocks(part.content?.raw ?? ""));
+}
+const titleCase = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+const slugOf = (s) => s.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+/**
+* Inline navigations of the used template parts → RawMenu[], in area order (header, footer, others) and document
+* order within a part. A part's single inline navigation is named after its area (`Footer navigation`), several
+* are numbered; a navigation's own `ariaLabel` wins. Links keep their order and nesting; a link to content not
+* proven public is left out, as in every other menu.
+*/
+function inlineMenus(parts, ctx, taken, nextId, dropped = { count: 0 }, all = parts) {
+	const out = [];
+	const ordered = parts.filter((p) => areaOf(p) && p.content?.raw).toSorted((a, b) => (AREA_ORDER.indexOf(areaOf(a)) + 1 || 99) - (AREA_ORDER.indexOf(areaOf(b)) + 1 || 99));
+	for (const p of ordered) {
+		const area = areaOf(p);
+		const navs = [];
+		const find = (blocks) => {
+			for (const b of blocks) if (b.name === "core/navigation") {
+				if (typeof b.attrs.ref !== "number" && b.children.length) navs.push(b);
+			} else find(b.children);
+		};
+		find(partTree(p, all));
+		navs.forEach((nav, i) => {
+			const name = strip(nav.attrs.ariaLabel) || `${titleCase(area)} navigation${navs.length > 1 ? ` ${i + 1}` : ""}`;
+			const base = slugOf(name) || `${area}-navigation`;
+			let slug = base;
+			for (let k = 2; taken.has(slug); k++) slug = `${base}-${k}`;
+			taken.add(slug);
+			const items = blockItems(nav.children, ctx, nextId, dropped);
+			if (items.length) out.push({
+				id: nextId(),
+				slug,
+				name,
+				items,
+				locations: [area]
+			});
+		});
+	}
+	return out;
+}
 /**
 * Where each navigation is shown: the template parts (`header`, `footer`) whose navigation block
 * refers to it. An empty navigation block without a `ref` shows the fallback — the most recent published one;
 * one with links of its own shows those (an inline menu, not a `wp_navigation` post).
 */
-function navigationLocations(parts, navigations) {
+function navigationLocations(parts, navigations, all = parts) {
 	const out = /* @__PURE__ */ new Map();
 	const fallback = [...navigations].toSorted((a, b) => (b.date_gmt ?? "").localeCompare(a.date_gmt ?? "") || b.id - a.id)[0]?.id;
 	const find = (blocks, area) => {
@@ -906,15 +1498,19 @@ function navigationLocations(parts, navigations) {
 		}
 	};
 	for (const p of parts) {
-		const area = p.area && p.area !== "uncategorized" ? p.area : void 0;
-		if (area && p.content?.raw) find(parseBlocks(p.content.raw), area);
+		const area = areaOf(p);
+		if (area && p.content?.raw) find(partTree(p, all), area);
 	}
 	return new Map([...out].map(([id, set]) => [id, [...set].toSorted()]));
 }
-/** Published `wp_navigation` posts → RawMenu[], slugs kept unique against the classic menus already read. */
-function blockMenus(navigations, parts, ctx, taken, dropped = { count: 0 }) {
+/**
+* Published `wp_navigation` posts, then the inline navigations of the used template parts → RawMenu[], slugs kept
+* unique against the classic menus already read. `templates` says which parts are used (see `usedParts`).
+*/
+function blockMenus(navigations, allParts, ctx, taken, dropped = { count: 0 }, templates = []) {
+	const parts = usedParts(allParts, templates);
 	const published = navigations.filter((n) => (n.status ?? "publish") === "publish").toSorted((a, b) => a.id - b.id);
-	const locations = navigationLocations(parts, published);
+	const locations = navigationLocations(parts, published, allParts);
 	let next = 0;
 	const out = [];
 	for (const n of published) {
@@ -931,6 +1527,7 @@ function blockMenus(navigations, parts, ctx, taken, dropped = { count: 0 }) {
 		if (where?.length) menu.locations = where;
 		out.push(menu);
 	}
+	out.push(...inlineMenus(parts, ctx, taken, () => -++next, dropped, allParts));
 	return out;
 }
 //#endregion
@@ -952,8 +1549,41 @@ const DENIED = new Set([
 	401,
 	403
 ]);
+/** REST taxonomies that hold no content: menus, block-pattern categories, multilingual bookkeeping. */
+const NOT_CONTENT_TAXONOMIES = new Set([
+	"category",
+	"post_tag",
+	"nav_menu",
+	"wp_pattern_category",
+	"post_format",
+	"language",
+	"post_translations",
+	"term_language",
+	"term_translations"
+]);
 /** A comment listing's name in `credential.fell_back`: `comments` (approved) or `comments:hold`. */
 const commentKey = (status) => status === "approve" ? "comments" : `comments:${status}`;
+/**
+* ACF fields of one REST post. `<name>_source` (SCF) states each field's type and label; a secret — a
+* `password` field, or, when no type is stated, a field named like one — is never read. ACF answers `[]`
+* for a post with no field group in REST.
+*/
+function acfOf(acf) {
+	if (!acf || Array.isArray(acf) || typeof acf !== "object") return {};
+	const out = {};
+	for (const [name, value] of Object.entries(acf)) {
+		if (name.endsWith("_source") && name.slice(0, -7) in acf) continue;
+		const source = acf[`${name}_source`];
+		const type = typeof source?.type === "string" ? source.type : void 0;
+		if (acfIsSecret(name, type)) continue;
+		out[name] = {
+			value: acfScrub(value),
+			...type ? { type } : {},
+			...typeof source?.label === "string" && source.label ? { label: source.label } : {}
+		};
+	}
+	return Object.keys(out).length ? { acf: out } : {};
+}
 /** What a visitor can open: published, not behind a post password. */
 const visible = (p) => p.status === "publish" && !p.password;
 const positiveInteger = (name, value) => {
@@ -1063,10 +1693,15 @@ async function fetchRestRawIR(options) {
 			return null;
 		}
 	});
-	const typesResp = await doFetch(`${origin}/wp-json/wp/v2/types`, { headers });
+	let typesResp = await doFetch(`${origin}/wp-json/wp/v2/types${options.auth && !rejected ? "?context=edit" : ""}`, { headers });
+	if (!typesResp.ok && options.auth && !rejected) {
+		await typesResp.body?.cancel();
+		typesResp = await doFetch(`${origin}/wp-json/wp/v2/types`, { headers: anonymous });
+	}
 	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 notViewable = new Set(postTypes.filter((t) => t.viewable === false).map((t) => t.slug));
 	const bases = postTypes.length ? postTypes.map((t) => ({
 		slug: t.slug,
 		base: t.rest_base
@@ -1090,24 +1725,52 @@ async function fetchRestRawIR(options) {
 		for (const c of lists.flat()) if (!byId.has(c.id)) byId.set(c.id, c);
 		return [...byId.values()];
 	};
-	const [categories, tags, users, media, restComments, ...postLists] = await Promise.all([
+	const taxResp = await schedule(async () => {
+		try {
+			const r = await doFetch(`${origin}/wp-json/wp/v2/taxonomies`, { headers });
+			if (!r.ok) {
+				await r.body?.cancel();
+				return {};
+			}
+			return await r.json();
+		} catch {
+			return {};
+		}
+	});
+	const extraTaxonomies = Object.values(taxResp && typeof taxResp === "object" ? taxResp : {}).filter((t) => t.rest_base && /^[\w-]+$/.test(t.rest_base) && !NOT_CONTENT_TAXONOMIES.has(t.slug)).map((t) => ({
+		taxonomy: t.slug,
+		base: t.rest_base
+	})).toSorted((a, b) => a.taxonomy.localeCompare(b.taxonomy));
+	const [categories, tags, users, media, restComments, ...lists] = await Promise.all([
 		getAll("categories"),
 		getAll("tags"),
 		getAll("users"),
 		getAll("media"),
 		commentListing(),
+		...extraTaxonomies.map((t) => getAll(t.base)),
 		...bases.map((b) => postListing(b.base))
 	]);
+	const extraTerms = lists.slice(0, extraTaxonomies.length);
+	const postLists = lists.slice(extraTaxonomies.length);
 	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 ?? ""
-	});
+	/** A term's public address, for menu items that name it; RawTerm carries none. */
+	const termLinks = /* @__PURE__ */ new Map();
+	for (const [tax, list] of [
+		["category", categories],
+		["post_tag", tags],
+		...extraTaxonomies.map((t, i) => [t.taxonomy, extraTerms[i] ?? []])
+	]) for (const t of list) {
+		if (t.link) termLinks.set(t.id, t.link);
+		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 = [];
 	const languagePairs = [];
@@ -1131,7 +1794,15 @@ async function fetchRestRawIR(options) {
 		});
 	};
 	for (const [i, base] of bases.entries()) for (const p of postLists[i] ?? []) {
-		const termRefs = [...p.categories ?? [], ...p.tags ?? []].map((id) => {
+		const custom = extraTaxonomies.flatMap((t) => {
+			const ids = p[t.base];
+			return Array.isArray(ids) ? ids.filter((id) => typeof id === "number") : [];
+		});
+		const termRefs = [
+			...p.categories ?? [],
+			...p.tags ?? [],
+			...custom
+		].map((id) => {
 			const t = termsById.get(id);
 			return t ? {
 				taxonomy: t.taxonomy,
@@ -1157,7 +1828,7 @@ async function fetchRestRawIR(options) {
 			status: p.status ?? "publish",
 			slug: p.slug,
 			title: p.title?.rendered ?? "",
-			link: p.link ?? null,
+			link: notViewable.has(base.slug) ? null : p.link ?? null,
 			guid: null,
 			author,
 			date: iso(p.date_gmt),
@@ -1171,7 +1842,8 @@ async function fetchRestRawIR(options) {
 			comment_status: p.comment_status ?? null,
 			ping_status: p.ping_status ?? null,
 			terms: termRefs,
-			meta
+			meta,
+			...acfOf(p.acf)
 		});
 	}
 	const attachments = media.map((m) => ({
@@ -1186,9 +1858,11 @@ async function fetchRestRawIR(options) {
 		mime: m.mime_type ?? null,
 		parent: m.post ?? null,
 		parent_resolved: m.post ? posts.some((p) => p.id === m.post) : null,
+		link: !m.post || posts.some((p) => p.id === m.post && visible(p)) ? m.link || null : null,
 		date: iso(m.date_gmt)
 	}));
 	const gaps = [];
+	if (postLists.some((list) => list.some((p) => p.acf !== void 0))) gaps.push("acf_partial");
 	let menus = [];
 	if (!authed) gaps.push("menus_require_auth");
 	else {
@@ -1227,11 +1901,12 @@ async function fetchRestRawIR(options) {
 				status: first.status
 			};
 		};
-		const [classic, items, navs, parts] = await Promise.all([
+		const [classic, items, navs, parts, templates] = await Promise.all([
 			listing("menus?context=edit"),
 			listing("menu-items?context=edit"),
 			listing("navigation?context=edit&status=publish"),
-			listing("template-parts?context=edit")
+			listing("template-parts?context=edit"),
+			listing("templates?context=edit&_fields=slug,content")
 		]);
 		const denied = [
 			classic,
@@ -1248,6 +1923,7 @@ async function fetchRestRawIR(options) {
 			["navigation", navs]
 		]) if (!l.status || l.status >= 400 && !DENIED.has(l.status) && l.status !== 404) warnings.push(`${name}: HTTP ${l.status} — skipped`);
 		const slugOf = new Map(posts.filter(visible).map((p) => [p.id, p.slug]));
+		const linkOf = new Map(posts.filter(visible).flatMap((p) => p.link ? [[p.id, p.link]] : []));
 		const ctx = {
 			origin,
 			postSlug: (id) => slugOf.get(id),
@@ -1255,6 +1931,8 @@ async function fetchRestRawIR(options) {
 				const t = termsById.get(id);
 				return t && t.taxonomy === taxonomy ? t.slug : void 0;
 			},
+			postLink: (id) => linkOf.get(id),
+			termLink: (taxonomy, id) => termsById.get(id)?.taxonomy === taxonomy ? termLinks.get(id) : void 0,
 			pages: posts.filter((p) => p.type === "page" && p.status === "publish" && !p.password).map((p) => ({
 				id: p.id,
 				parent: p.parent ?? null,
@@ -1266,7 +1944,7 @@ async function fetchRestRawIR(options) {
 		};
 		const dropped = { count: 0 };
 		menus = classicMenus(DENIED.has(classic.status) ? [] : classic.items, DENIED.has(items.status) ? [] : items.items, ctx, dropped);
-		menus.push(...blockMenus(DENIED.has(navs.status) ? [] : navs.items, parts.status < 400 ? parts.items : [], ctx, new Set(menus.map((m) => m.slug)), dropped));
+		menus.push(...blockMenus(DENIED.has(navs.status) ? [] : navs.items, parts.status < 400 ? parts.items : [], ctx, new Set(menus.map((m) => m.slug)), dropped, templates.status < 400 ? templates.items : []));
 		if (dropped.count) warnings.push(`menus: ${dropped.count} item(s) are drafts or point at content not proven public (unpublished, password-protected, or not read by this import) — left out`);
 	}
 	const postIds = new Set(posts.map((p) => p.id));
@@ -1288,6 +1966,62 @@ async function fetchRestRawIR(options) {
 		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`);
+	let redirects = [];
+	let redirectsExcluded = [];
+	gaps.push("redirects_partial");
+	const namespaces = Array.isArray(about?.namespaces) ? about.namespaces : void 0;
+	const redirection = namespaces ? namespaces.includes("redirection/v1") : void 0;
+	if (redirection && !authed) gaps.push("redirects_require_auth");
+	else if (authed && redirection !== false) {
+		const all = async (path) => {
+			const items = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (let page = 0; page < (maxPages ?? 500); page++) {
+				const r = await schedule(() => doFetch(`${origin}/wp-json/redirection/v1/${path}?per_page=200&page=${page}`, { headers }));
+				if (!r.ok) {
+					await r.body?.cancel();
+					return {
+						items,
+						status: r.status
+					};
+				}
+				const body = await r.json();
+				const fresh = (Array.isArray(body.items) ? body.items : []).filter((x) => !seen.has(x.id));
+				for (const x of fresh) {
+					seen.add(x.id);
+					items.push(x);
+				}
+				if (!fresh.length || items.length >= Number(body.total ?? 0)) break;
+			}
+			return {
+				items,
+				status: 200
+			};
+		};
+		const settings = async () => {
+			try {
+				const r = await schedule(() => doFetch(`${origin}/wp-json/redirection/v1/setting`, { headers }));
+				if (!r.ok) {
+					await r.body?.cancel();
+					return;
+				}
+				const body = await r.json();
+				return body?.settings && typeof body.settings === "object" ? body.settings : void 0;
+			} catch {
+				return;
+			}
+		};
+		const [rules, groups, siteFlags] = await Promise.all([
+			all("redirect"),
+			all("group"),
+			settings()
+		]);
+		if (DENIED.has(rules.status)) {
+			gaps.push("redirects_require_auth");
+			warnings.push(`redirects: HTTP ${rules.status} with the credential — the user may not manage Redirection; its rules not read`);
+		} else if (rules.status === 200) ({redirects, excluded: redirectsExcluded} = redirectionRules(rules.items, groups.status === 200 ? groups.items : [], origin, siteFlags));
+		else if (redirection) warnings.push(`redirects: HTTP ${rules.status} — Redirection's rules not read`);
+	}
 	return {
 		raw: {
 			version: MIGRATION_CONTRACT_VERSION,
@@ -1300,7 +2034,9 @@ async function fetchRestRawIR(options) {
 				...typeof about?.name === "string" && strip(about.name) ? { title: strip(about.name) } : {},
 				...typeof about?.description === "string" && strip(about.description) ? { description: strip(about.description) } : {},
 				...typeof about?.url === "string" && about.url ? { base_site_url: about.url } : {},
-				...typeof about?.home === "string" && about.home ? { base_blog_url: about.home } : {}
+				...typeof about?.home === "string" && about.home ? { base_blog_url: about.home } : {},
+				...typeof about?.timezone_string === "string" && about.timezone_string ? { timezone: about.timezone_string } : {},
+				...about?.gmt_offset !== void 0 && about.gmt_offset !== null && about.gmt_offset !== "" && Number.isFinite(Number(about.gmt_offset)) ? { gmt_offset: Number(about.gmt_offset) } : {}
 			},
 			authors: users.map((u) => ({
 				id: u.id,
@@ -1313,6 +2049,8 @@ async function fetchRestRawIR(options) {
 			attachments,
 			comments,
 			...menus.length ? { menus } : {},
+			...redirects.length ? { redirects } : {},
+			...redirectsExcluded.length ? { redirects_excluded: redirectsExcluded } : {},
 			...languagePairs.length ? { language_pairs: languagePairs } : {}
 		},
 		warnings,
@@ -1355,6 +2093,8 @@ function relationOver(targets) {
 		ref: (entry) => single ? entry.ref : entry
 	};
 }
+/** Post, term, user or attachment ids of an ACF reference value: ids, numeric strings or `{ ID }` objects. */
+const idsOf = (v) => (Array.isArray(v) ? v : [v]).map((x) => typeof x === "number" ? x : typeof x === "string" && /^\d+$/.test(x) ? Number(x) : x && typeof x === "object" ? Number(x.ID ?? x.id ?? x.term_id) : NaN).filter((n) => Number.isSafeInteger(n) && n > 0);
 function rawToContentrain(raw, opts) {
 	const updatedBy = opts?.updatedBy ?? "@contentrain/wp-import";
 	const locale = normLocale(raw.site.language) || "en";
@@ -1386,12 +2126,15 @@ function rawToContentrain(raw, opts) {
 		title_fallback: 0,
 		meta_fields: {},
 		acf_fields: {},
+		acf_outside_choices: {},
+		acf_datetime_unzoned: 0,
 		skipped_types: [],
 		dropped_relations: 0,
 		models: {},
 		locales,
 		translation_groups: translationGroups,
-		password_protected_drafts: 0
+		password_protected_drafts: 0,
+		site_title_missing: false
 	};
 	const importMeta = (status, extra = {}) => ({
 		status,
@@ -1449,6 +2192,100 @@ function rawToContentrain(raw, opts) {
 		});
 	}
 	const mediaRef = (id) => raw.attachments.some((a) => a.id === id) ? hexId(`media:${id}`) : null;
+	const termById = new Map(raw.terms.map((t) => [t.id, t]));
+	const authorById = new Map(raw.authors.filter((a) => a.id !== null).map((a) => [a.id, a]));
+	const refOf = (kind, id) => {
+		if (kind === "post") return postEntry.get(id) ?? null;
+		if (kind === "media") {
+			const m = mediaRef(id);
+			return m ? {
+				model: "media",
+				ref: m
+			} : null;
+		}
+		if (kind === "user") {
+			const a = authorById.get(id);
+			return a && models.authors ? {
+				model: "authors",
+				ref: authorId(slugify(a.login))
+			} : null;
+		}
+		if (kind === "term") {
+			const t = termById.get(id);
+			return t && models[taxModelId(t.taxonomy)] ? {
+				model: taxModelId(t.taxonomy),
+				ref: termId(t.taxonomy, t.slug)
+			} : null;
+		}
+		return null;
+	};
+	/** Every ACF field on these posts: its definition, or — for a reference — its kind and target models. */
+	const acfPlan = (items, taken) => {
+		const out = /* @__PURE__ */ new Map();
+		for (const p of items) for (const [k, acf] of Object.entries(p.acf ?? {})) {
+			if (taken(k) || acf.value === null || acf.value === void 0 || acf.value === "" || acf.value === false && acf.type !== "true_false") continue;
+			const kind = acf.type ? ACF_REFERENCE_TYPES[acf.type] : void 0;
+			if (kind === "address") {
+				const def = Array.isArray(acf.value) ? {
+					type: "array",
+					items: "url"
+				} : { type: "url" };
+				const cur = out.get(k);
+				out.set(k, {
+					def: cur?.def ?? {
+						...def,
+						...acf.label ? { label: strip(acf.label) } : {}
+					},
+					kind,
+					multiple: false,
+					models: /* @__PURE__ */ new Set()
+				});
+				continue;
+			}
+			if (kind) {
+				const cur = out.get(k) ?? {
+					kind,
+					multiple: acf.type === "relationship" || acf.type === "gallery",
+					models: /* @__PURE__ */ new Set()
+				};
+				if (Array.isArray(acf.value)) cur.multiple = true;
+				for (const id of idsOf(acf.value)) {
+					const r = refOf(kind, id);
+					if (r) cur.models.add(r.model);
+				}
+				out.set(k, cur);
+				continue;
+			}
+			const def = acfFieldDef(k, acfScrub(acf.value), {
+				type: acf.type,
+				label: acf.label
+			});
+			if (!def) continue;
+			const cur = out.get(k);
+			out.set(k, {
+				def: cur?.def ? mergeFieldDef(cur.def, def) : def,
+				multiple: false,
+				models: /* @__PURE__ */ new Set()
+			});
+		}
+		for (const [k, plan] of out) if (!plan.def && !plan.models.size) out.delete(k);
+		return out;
+	};
+	const acfRefs = (plan, value) => {
+		const refs = idsOf(value).map((id) => refOf(plan.kind, id)).filter((r) => !!r);
+		const missing = idsOf(value).length - refs.length;
+		if (missing > 0) report.dropped_relations += missing;
+		if (!refs.length) return void 0;
+		const poly = plan.models.size > 1;
+		const one = (r) => poly ? r : r.ref;
+		return plan.multiple ? refs.map(one) : one(refs[0]);
+	};
+	const addressOf = (v) => {
+		if (Array.isArray(v)) return v.map(addressOf).filter(Boolean);
+		if (typeof v !== "number") return v;
+		const t = postById.get(v);
+		return t && t.status === "publish" && !t.password ? t.link ?? void 0 : void 0;
+	};
 	const titleOf = (p) => {
 		const t = strip(p.title);
 		if (t) return t;
@@ -1788,31 +2625,32 @@ function rawToContentrain(raw, opts) {
 			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";
+		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 === "object" ? "object" : t,
+					type: t,
 					label: k,
-					description: "ACF",
 					order: o += 10
 				};
-				report.acf_fields[k] = t;
+				report.meta_fields[k] = t;
 			}
 		}
+		const acfFields = acfPlan(typeItems, (k) => !!fields[k]);
+		for (const [k, plan] of acfFields) {
+			const def = plan.def ?? {
+				type: plan.multiple ? "relations" : "relation",
+				model: plan.models.size > 1 ? [...plan.models].toSorted() : [...plan.models][0]
+			};
+			fields[k] = {
+				...def,
+				...def.label ? {} : { label: k },
+				description: def.description ?? "ACF",
+				order: o += 10
+			};
+			report.acf_fields[k] = plan.def ? plan.def.type : `${def.type}:${[...plan.models].toSorted().join("|")}`;
+		}
 		const covered = locales.filter((l) => l === locale || typeItems.some((p) => postLocale(p) === l));
 		addModel({
 			id: mid,
@@ -1861,7 +2699,22 @@ function rawToContentrain(raw, opts) {
 			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;
+			for (const [k, acf] of Object.entries(p.acf ?? {})) {
+				const plan = acfFields.get(k);
+				if (!plan || k in e) continue;
+				const ctx = {
+					timeZone: raw.site.timezone,
+					gmtOffset: raw.site.gmt_offset,
+					dropped: () => {
+						report.acf_outside_choices[k] = (report.acf_outside_choices[k] ?? 0) + 1;
+					},
+					unzoned: () => {
+						report.acf_datetime_unzoned++;
+					}
+				};
+				const v = plan.def ? acfValue(plan.def, plan.kind === "address" ? addressOf(acf.value) : acfRows(acfScrub(acf.value)), ctx) : acfRefs(plan, acf.value);
+				if (v !== void 0) e[k] = v;
+			}
 			contentBucket[id] = e;
 			metaBucket[id] = mapStatus(p);
 		}
@@ -1993,7 +2846,7 @@ function rawToContentrain(raw, opts) {
 				name: strip(m.name),
 				slug: slugify(m.slug) || `menu-${m.id}`,
 				items: m.items.map((i) => itemRef(i.id)),
-				wp_id: m.id,
+				...m.id !== null && m.id > 0 ? { wp_id: m.id } : {},
 				...m.locations?.length ? { locations: m.locations } : {}
 			};
 			metas.menus[mid] = importMeta("published");
@@ -2157,7 +3010,7 @@ function rawToContentrain(raw, opts) {
 		}
 	});
 	siteEntry = pick({
-		title: strip(raw.site.title) || "Site",
+		title: strip(raw.site.title),
 		tagline: raw.site.description,
 		url: raw.site.url,
 		language: raw.site.language
@@ -2168,6 +3021,7 @@ function rawToContentrain(raw, opts) {
 		"language"
 	]));
 	siteMeta = importMeta("published");
+	report.site_title_missing = !siteEntry.title;
 	const vocabTerms = {};
 	for (const m of menus) for (const i of m.items) {
 		const k = slugify(strip(i.title));