@contentrain/wp-import 0.6.0 → 0.8.0

package/dist/index.mjs

@@ -675,6 +675,734 @@ 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-menus.ts
+const targetOf = (kind, object, id, url, ctx) => {
+	const objectId = id && id > 0 ? id : null;
+	if (kind === "post_type" && object) {
+		const slug = objectId ? ctx.postSlug(objectId) : void 0;
+		return {
+			kind: "post",
+			post_type: object,
+			id: objectId,
+			slug: slug ?? null,
+			resolved: slug !== void 0
+		};
+	}
+	if (kind === "taxonomy" && object) {
+		const slug = objectId ? ctx.termSlug(object, objectId) : void 0;
+		return {
+			kind: "term",
+			taxonomy: object,
+			id: objectId,
+			slug: slug ?? null,
+			resolved: slug !== void 0
+		};
+	}
+	if (kind === "post_type_archive" && object) return {
+		kind: "archive",
+		post_type: object,
+		resolved: true
+	};
+	if (url) return {
+		kind: "url",
+		url,
+		resolved: true
+	};
+	return {
+		kind: "unknown",
+		resolved: false
+	};
+};
+/**
+* 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.
+*/
+function hiddenItems(items, drop) {
+	const parentOf = new Map(items.filter(drop).map((i) => [i.id, i.parent || null]));
+	const lift = (parent) => {
+		const seen = /* @__PURE__ */ new Set();
+		let p = parent;
+		while (p !== null && parentOf.has(p) && !seen.has(p)) {
+			seen.add(p);
+			p = parentOf.get(p) ?? null;
+		}
+		return p;
+	};
+	return {
+		gone: new Set(parentOf.keys()),
+		lift
+	};
+}
+/**
+* The post a plain permalink names (`/?page_id=14`, `/?p=14`) on this site: 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 (u.origin !== new URL(origin).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 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));
+		const menu = {
+			id: m.id,
+			slug: m.slug ?? "",
+			name: strip(m.name ?? m.slug ?? ""),
+			items: own.map((i) => {
+				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),
+					target_attr: i.target || null,
+					classes: (i.classes ?? []).filter(Boolean),
+					description: i.description ?? "",
+					status: i.status ?? "publish"
+				};
+				if (item.parent && !ids.has(item.parent)) item.parent_unresolved = true;
+				return item;
+			})
+		};
+		const locations = (m.locations ?? []).filter(Boolean).toSorted();
+		if (locations.length) menu.locations = locations;
+		out.push(menu);
+	}
+	return out;
+}
+/** Serialized block comments (`<!-- wp:name {attrs} /-->`, `<!-- /wp:name -->`). Same grammar as the facts builder parser. */
+const BLOCK_TOKEN = /<!--\s+(\/)?wp:([a-z][a-z0-9_-]*\/)?([a-z][a-z0-9_-]*)\s+({(?:(?!}\s+\/?-->)[\s\S])*?}\s+)?(\/)?-->/g;
+function parseBlocks(content) {
+	const root = {
+		name: "root",
+		attrs: {},
+		children: []
+	};
+	const stack = [root];
+	const token = new RegExp(BLOCK_TOKEN.source, "g");
+	let m;
+	while (m = token.exec(content)) {
+		const [, closer, ns, local, json, selfClose] = m;
+		if (closer) {
+			if (stack.length > 1) stack.pop();
+			continue;
+		}
+		let attrs = {};
+		if (json) try {
+			attrs = JSON.parse(json);
+		} catch {
+			attrs = {};
+		}
+		const block = {
+			name: `${ns ? ns.slice(0, -1) : "core"}/${local}`,
+			attrs,
+			children: []
+		};
+		stack[stack.length - 1].children.push(block);
+		if (!selfClose) stack.push(block);
+	}
+	return root.children;
+}
+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 {
+		return url;
+	}
+};
+/** The block editor's link kinds → the classic menu item types. */
+const KIND = {
+	"post-type": "post_type",
+	taxonomy: "taxonomy",
+	custom: "custom"
+};
+/**
+* Menu items of one `wp_navigation` body. Links and submenus become items; a page list becomes the
+* 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);
+		items.push({
+			id,
+			title: b.title,
+			order: items.length + 1,
+			parent,
+			url: url ?? null,
+			target: targetOf(b.kind, b.object, b.id, url, ctx),
+			target_attr: b.newTab ? "_blank" : null,
+			classes: (b.className ?? "").split(/\s+/).filter(Boolean),
+			description: b.description ?? "",
+			status: "publish"
+		});
+		return id;
+	};
+	const pageList = (parentPage, parent) => {
+		const kids = ctx.pages.filter((p) => (p.parent ?? 0) === parentPage).toSorted((a, b) => a.menu_order - b.menu_order || a.title.localeCompare(b.title));
+		for (const p of kids) {
+			const id = push({
+				title: p.title,
+				url: p.link ?? void 0,
+				kind: "post_type",
+				object: "page",
+				id: p.id
+			}, parent);
+			pageList(p.id, id);
+		}
+	};
+	const walk = (blocks, parent) => {
+		for (const b of blocks) {
+			const a = b.attrs;
+			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);
+				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;
+				}
+				const id = push({
+					title: strip(a.label),
+					url: str(a.url),
+					kind,
+					object,
+					id: typeof a.id === "number" ? a.id : void 0,
+					newTab: a.opensInNewTab === true,
+					className: str(a.className),
+					description: str(a.description)
+				}, parent);
+				walk(b.children, id);
+			} else if (b.name === "core/home-link") push({
+				title: strip(a.label) || "Home",
+				url: "/",
+				className: str(a.className)
+			}, parent);
+			else if (b.name === "core/page-list") pageList(typeof a.parentPageID === "number" ? a.parentPageID : 0, parent);
+			else walk(b.children, parent);
+		}
+	};
+	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, 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) => {
+		for (const b of blocks) {
+			if (b.name === "core/navigation") {
+				const ref = typeof b.attrs.ref === "number" ? b.attrs.ref : b.children.length ? void 0 : fallback;
+				if (ref !== void 0) (out.get(ref) ?? out.set(ref, /* @__PURE__ */ new Set()).get(ref)).add(area);
+				continue;
+			}
+			find(b.children, area);
+		}
+	};
+	for (const p of parts) {
+		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, 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, allParts);
+	let next = 0;
+	const out = [];
+	for (const n of published) {
+		let slug = n.slug || `navigation-${n.id}`;
+		while (taken.has(slug)) slug = `${slug}-nav`;
+		taken.add(slug);
+		const menu = {
+			id: n.id,
+			slug,
+			name: strip(n.title?.raw || n.title?.rendered || "") || slug,
+			items: navigationItems(n.content?.raw ?? "", ctx, () => -++next, dropped)
+		};
+		const where = locations.get(n.id);
+		if (where?.length) menu.locations = where;
+		out.push(menu);
+	}
+	out.push(...inlineMenus(parts, ctx, taken, () => -++next, dropped, allParts));
+	return out;
+}
+//#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";
@@ -693,8 +1421,43 @@ 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) => {
 	if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`${name} must be a positive safe integer`);
 	return value;
@@ -790,10 +1553,27 @@ async function fetchRestRawIR(options) {
 		const rest = await Promise.all(Array.from({ length: wanted - 1 }, (_v, i) => pageData(i + 2).then((r) => r.items)));
 		return firstPage.concat(...rest);
 	};
-	const typesResp = await doFetch(`${origin}/wp-json/wp/v2/types`, { headers });
+	const about = await schedule(async () => {
+		try {
+			const index = await doFetch(`${origin}/wp-json/`, { headers });
+			if (!index.ok) {
+				await index.body?.cancel();
+				return null;
+			}
+			return await index.json();
+		} catch {
+			return null;
+		}
+	});
+	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
@@ -817,16 +1597,39 @@ 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, {
+	for (const [tax, list] of [
+		["category", categories],
+		["post_tag", tags],
+		...extraTaxonomies.map((t, i) => [t.taxonomy, extraTerms[i] ?? []])
+	]) for (const t of list) termsById.set(t.id, {
 		id: t.id,
 		taxonomy: tax,
 		slug: t.slug,
@@ -858,7 +1661,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,
@@ -884,7 +1695,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),
@@ -898,7 +1709,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) => ({
@@ -915,6 +1727,89 @@ async function fetchRestRawIR(options) {
 		parent_resolved: m.post ? posts.some((p) => p.id === m.post) : 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 {
+		const listing = async (path) => {
+			const url = (page) => `${origin}/wp-json/wp/v2/${path}${path.includes("?") ? "&" : "?"}per_page=${perPage}&page=${page}`;
+			const first = await schedule(async () => {
+				const r = await doFetch(url(1), { headers });
+				if (!r.ok) {
+					await r.body?.cancel();
+					return {
+						items: [],
+						status: r.status,
+						pages: 1
+					};
+				}
+				const items = await r.json();
+				return {
+					items: Array.isArray(items) ? items : [],
+					status: r.status,
+					pages: Math.max(1, Number(r.headers.get("x-wp-totalpages") ?? "1") || 1)
+				};
+			});
+			const wanted = maxPages !== void 0 ? Math.min(first.pages, maxPages) : first.pages;
+			const rest = await Promise.all(Array.from({ length: wanted - 1 }, (_v, i) => schedule(async () => {
+				const r = await doFetch(url(i + 2), { headers });
+				if (!r.ok) {
+					await r.body?.cancel();
+					warnings.push(`${path.split("?")[0]}: page ${i + 2} HTTP ${r.status} — skipped`);
+					return [];
+				}
+				const items = await r.json();
+				return Array.isArray(items) ? items : [];
+			})));
+			return {
+				items: first.items.concat(...rest),
+				status: first.status
+			};
+		};
+		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("templates?context=edit&_fields=slug,content")
+		]);
+		const denied = [
+			classic,
+			items,
+			navs
+		].filter((l) => DENIED.has(l.status));
+		if (denied.length) {
+			gaps.push("menus_require_auth");
+			warnings.push(`menus: HTTP ${denied[0].status} with the credential — the user may not edit theme options; menus not read`);
+		}
+		for (const [name, l] of [
+			["menus", classic],
+			["menu-items", items],
+			["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 ctx = {
+			origin,
+			postSlug: (id) => slugOf.get(id),
+			termSlug: (taxonomy, id) => {
+				const t = termsById.get(id);
+				return t && t.taxonomy === taxonomy ? t.slug : void 0;
+			},
+			pages: posts.filter((p) => p.type === "page" && p.status === "publish" && !p.password).map((p) => ({
+				id: p.id,
+				parent: p.parent ?? null,
+				menu_order: p.menu_order ?? 0,
+				title: strip(p.title),
+				link: p.link ?? null,
+				slug: p.slug
+			}))
+		};
+		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, 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));
 	const commentIds = new Set(restComments.map((c) => c.id));
 	const comments = restComments.map((c) => ({
@@ -941,7 +1836,15 @@ async function fetchRestRawIR(options) {
 				kind: authed ? "rest_auth" : "rest_public",
 				tool: options.tool ?? "@contentrain/wp-import"
 			},
-			site: { url: origin },
+			site: {
+				url: origin,
+				...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?.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,
 				login: u.slug,
@@ -952,13 +1855,15 @@ async function fetchRestRawIR(options) {
 			posts,
 			attachments,
 			comments,
+			...menus.length ? { menus } : {},
 			...languagePairs.length ? { language_pairs: languagePairs } : {}
 		},
 		warnings,
 		credential: {
 			status: !options.auth ? "none" : fellBack.size ? "rejected" : "accepted",
 			fell_back: [...fellBack].toSorted()
-		}
+		},
+		gaps
 	};
 }
 //#endregion
@@ -993,6 +1898,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";
@@ -1024,12 +1931,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,
@@ -1087,6 +1997,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;
@@ -1426,31 +2430,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,
@@ -1499,7 +2504,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);
 		}
@@ -1537,7 +2557,13 @@ function rawToContentrain(raw, opts) {
 					type: "integer",
 					label: "WP term ID",
 					order: 40
-				}
+				},
+				...menus.some((m) => m.locations?.length) ? { locations: {
+					type: "array",
+					items: "string",
+					label: "Locations",
+					order: 50
+				} } : {}
 			}
 		});
 		const toTarget = relationOver([...contentModelIds, ...taxonomies.map(taxModelId)]);
@@ -1625,7 +2651,8 @@ 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");
 			for (const i of m.items) {
@@ -1634,7 +2661,7 @@ function rawToContentrain(raw, opts) {
 					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,
+					...i.id > 0 ? { wp_id: i.id } : {},
 					open_in_new_tab: i.target_attr === "_blank"
 				};
 				if (i.parent && !i.parent_unresolved) e.parent = itemRef(i.parent);
@@ -1788,7 +2815,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
@@ -1799,6 +2826,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));