@contentrain/wp-import 0.5.7 → 0.7.0

package/dist/index.mjs

@@ -675,6 +675,265 @@ function guessMime(u) {
 	return MIME[(u.split("?")[0]?.split(".").pop() ?? "").toLowerCase()] ?? null;
 }
 //#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
+	};
+}
+/** 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)));
+		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;
+	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 }) {
+	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);
+				if (kind === "post_type" && typeof a.id === "number" && !ctx.postSlug(a.id)) {
+					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(parseBlocks(content), null);
+	return items;
+}
+/**
+* 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) {
+	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 = p.area && p.area !== "uncategorized" ? p.area : void 0;
+		if (area && p.content?.raw) find(parseBlocks(p.content.raw), 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 }) {
+	const published = navigations.filter((n) => (n.status ?? "publish") === "publish").toSorted((a, b) => a.id - b.id);
+	const locations = navigationLocations(parts, published);
+	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);
+	}
+	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,6 +952,10 @@ const DENIED = new Set([
 	401,
 	403
 ]);
+/** A comment listing's name in `credential.fell_back`: `comments` (approved) or `comments:hold`. */
+const commentKey = (status) => status === "approve" ? "comments" : `comments:${status}`;
+/** 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;
@@ -721,20 +984,36 @@ async function fetchRestRawIR(options) {
 			});
 		}
 	};
-	const headers = { accept: "application/json" };
-	if (options.auth) headers.authorization = `Basic ${Buffer.from(`${options.auth.user}:${options.auth.appPassword}`).toString("base64")}`;
+	const anonymous = { accept: "application/json" };
+	let headers = anonymous;
+	if (options.auth) headers = {
+		...anonymous,
+		authorization: `Basic ${Buffer.from(`${options.auth.user}:${options.auth.appPassword}`).toString("base64")}`
+	};
+	const fellBack = /* @__PURE__ */ new Set();
+	let rejected = false;
+	if (options.auth) {
+		const me = await doFetch(`${origin}/wp-json/wp/v2/users/me`, { headers });
+		await me.body?.cancel();
+		if (me.status === 401 || me.status === 403) {
+			rejected = true;
+			headers = anonymous;
+			warnings.push(`credential: HTTP ${me.status} on users/me — the site rejected it; imported the public listings only`);
+		}
+	}
 	/**
 	* Every page of `path`. With `fallback`, a first page the site refuses
 	* (400/401/403 — the credential may not list those statuses or the edit
 	* context) is retried as `fallback` instead of dropping the collection;
 	* an empty `fallback` means there is nothing public to retry, so it is
-	* skipped with that warning.
+	* skipped with that warning. The retry is anonymous, and `key` goes into
+	* `credential.fell_back`.
 	*/
-	const getAll = async (path, fallback) => {
+	const getAll = async (path, fallback, key, send = headers) => {
 		const label = path.split("?")[0];
 		const url = (page) => `${origin}/wp-json/wp/v2/${path}${path.includes("?") ? "&" : "?"}per_page=${perPage}&page=${page}`;
 		const pageData = (page) => schedule(async () => {
-			const response = await doFetch(url(page), { headers });
+			const response = await doFetch(url(page), { headers: send });
 			if (!response.ok) {
 				await response.body?.cancel();
 				if (page === 1 && fallback !== void 0 && DENIED.has(response.status)) return {
@@ -761,7 +1040,8 @@ async function fetchRestRawIR(options) {
 		const first = await pageData(1);
 		if (first.denied !== void 0) {
 			warnings.push(`${label}: HTTP ${first.denied} for ${path.split("?")[1]} with the credential — ${fallback ? "fell back to the public listing" : "skipped (no public listing)"}`);
-			return fallback ? getAll(fallback) : [];
+			fellBack.add(key ?? label);
+			return fallback ? getAll(fallback, void 0, void 0, anonymous) : [];
 		}
 		const totalPages = first.pages;
 		const firstPage = first.items;
@@ -771,6 +1051,18 @@ 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 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;
+		}
+	});
 	const typesResp = await doFetch(`${origin}/wp-json/wp/v2/types`, { headers });
 	const types = typesResp.ok ? await typesResp.json() : {};
 	if (!typesResp.ok) warnings.push(`types: HTTP ${typesResp.status} — importing posts and pages only`);
@@ -785,10 +1077,15 @@ async function fetchRestRawIR(options) {
 		slug: "page",
 		base: "pages"
 	}];
-	const postListing = (base) => options.auth ? getAll(`${base}?status=${AUTH_POST_STATUSES.join(",")}&context=edit`, base) : getAll(base);
+	if (rejected) {
+		for (const b of bases) fellBack.add(b.base);
+		for (const status of AUTH_COMMENT_STATUSES) fellBack.add(commentKey(status));
+	}
+	const authed = options.auth !== void 0 && !rejected;
+	const postListing = (base) => authed ? getAll(`${base}?status=${AUTH_POST_STATUSES.join(",")}&context=edit`, base, base) : getAll(base);
 	const commentListing = async () => {
-		if (!options.auth) return getAll("comments");
-		const lists = await Promise.all(AUTH_COMMENT_STATUSES.map((status) => getAll(`comments?status=${status}&context=edit`, status === "approve" ? "comments" : "")));
+		if (!authed) return getAll("comments");
+		const lists = await Promise.all(AUTH_COMMENT_STATUSES.map((status) => getAll(`comments?status=${status}&context=edit`, status === "approve" ? "comments" : "", commentKey(status))));
 		const byId = /* @__PURE__ */ new Map();
 		for (const c of lists.flat()) if (!byId.has(c.id)) byId.set(c.id, c);
 		return [...byId.values()];
@@ -891,6 +1188,87 @@ async function fetchRestRawIR(options) {
 		parent_resolved: m.post ? posts.some((p) => p.id === m.post) : null,
 		date: iso(m.date_gmt)
 	}));
+	const gaps = [];
+	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] = await Promise.all([
+			listing("menus?context=edit"),
+			listing("menu-items?context=edit"),
+			listing("navigation?context=edit&status=publish"),
+			listing("template-parts?context=edit")
+		]);
+		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));
+		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) => ({
@@ -914,10 +1292,16 @@ async function fetchRestRawIR(options) {
 		raw: {
 			version: MIGRATION_CONTRACT_VERSION,
 			provenance: {
-				kind: options.auth ? "rest_auth" : "rest_public",
+				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 } : {}
+			},
 			authors: users.map((u) => ({
 				id: u.id,
 				login: u.slug,
@@ -928,9 +1312,15 @@ async function fetchRestRawIR(options) {
 			posts,
 			attachments,
 			comments,
+			...menus.length ? { menus } : {},
 			...languagePairs.length ? { language_pairs: languagePairs } : {}
 		},
-		warnings
+		warnings,
+		credential: {
+			status: !options.auth ? "none" : fellBack.size ? "rejected" : "accepted",
+			fell_back: [...fellBack].toSorted()
+		},
+		gaps
 	};
 }
 //#endregion
@@ -1509,7 +1899,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)]);
@@ -1597,7 +1993,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
+				wp_id: m.id,
+				...m.locations?.length ? { locations: m.locations } : {}
 			};
 			metas.menus[mid] = importMeta("published");
 			for (const i of m.items) {
@@ -1606,7 +2003,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);
@@ -1837,8 +2234,44 @@ function rawToContentrain(raw, opts) {
 }
 //#endregion
 //#region src/comments.ts
+/**
+* The comments that may leave the source site (see `CommentsExport.comments`). An allowlist, so it
+* fails closed: a comment travels only when its entry is in this RawIR and public, and its status is
+* approved (`'1'`, or none) or pending (`'0'`). Everything else is counted in `excluded`: spam, trash,
+* WordPress's `post-trashed`, a plugin's own status, a post this RawIR does not hold.
+*/
+function selectComments(raw) {
+	const posts = new Map(raw.posts.map((p) => [p.id, p]));
+	const excluded = {};
+	const count = (key) => {
+		excluded[key] = (excluded[key] ?? 0) + 1;
+	};
+	const comments = [];
+	for (const c of raw.comments ?? []) {
+		const post = posts.get(c.post);
+		if (!post) {
+			count("unknown_entry");
+			continue;
+		}
+		if (post.status !== "publish" || post.password !== null && post.password !== void 0 && post.password !== "") {
+			count("non_public_entry");
+			continue;
+		}
+		const status = c.approved ?? "1";
+		if (status === "1" || status === "0") {
+			comments.push(c);
+			continue;
+		}
+		count(status === "spam" ? "spam" : status === "trash" ? "trash" : "other_status");
+	}
+	return {
+		comments,
+		excluded
+	};
+}
 function buildCommentsExport(raw, entries, opts) {
 	const threadsClosed = raw.posts.filter((p) => p.comment_status && p.comment_status !== "open").map((p) => p.id);
+	const { comments, excluded } = selectComments(raw);
 	return {
 		version: MIGRATION_CONTRACT_VERSION,
 		format: COMMENTS_EXPORT_FORMAT,
@@ -1847,7 +2280,8 @@ function buildCommentsExport(raw, entries, opts) {
 		generated_at: opts?.generated_at ?? (/* @__PURE__ */ new Date()).toISOString(),
 		entries,
 		threads_closed: threadsClosed.length ? threadsClosed : void 0,
-		comments: raw.comments ?? []
+		comments,
+		excluded: Object.keys(excluded).length ? excluded : void 0
 	};
 }
 /** Handoff summary for the export: counts + closed threads + what could not be addressed. */
@@ -1870,7 +2304,8 @@ function summarizeComments(exp) {
 		types: byType,
 		export: { format: exp.format },
 		threads_closed: exp.threads_closed,
-		unresolved: unresolved.length ? unresolved : void 0
+		unresolved: unresolved.length ? unresolved : void 0,
+		excluded: exp.excluded
 	};
 }
 //#endregion
@@ -2124,6 +2559,6 @@ function formatSourceDeltaReport(plan) {
 	return `${lines.join("\n")}\n`;
 }
 //#endregion
-export { DEFAULT_IMPORTERS, DEFAULT_TAXONOMIES, PLUGIN_META, SKIP_TYPES, buildCommentsExport, canon, fetchRestRawIR, formatSourceDeltaReport, hexId, looksSerialized, parseWxr, phpUnserialize, planSourceDelta, rawToContentrain, slugify, strip, summarizeComments, taxModelId, tryUnserialize };
+export { DEFAULT_IMPORTERS, DEFAULT_TAXONOMIES, PLUGIN_META, SKIP_TYPES, buildCommentsExport, canon, fetchRestRawIR, formatSourceDeltaReport, hexId, looksSerialized, parseWxr, phpUnserialize, planSourceDelta, rawToContentrain, selectComments, slugify, strip, summarizeComments, taxModelId, tryUnserialize };
 
 //# sourceMappingURL=index.mjs.map