@contentrain/emitter-astro 0.16.1 → 0.18.0

package/dist/index.mjs

@@ -722,9 +722,7 @@ function scaffoldFiles(ir, options, noindex = [], redirectsConfig = null, runtim
 				"@tailwindcss/vite": "^4.0.0"
 			} : {},
 			...sitemap ? { "@astrojs/sitemap": "^3.7.0" } : {},
-			...images ? { sharp: "^0.34.0" } : {}
-		},
-		devDependencies: {
+			...images ? { sharp: "^0.34.0" } : {},
 			"@astrojs/check": "^0.9.0",
 			typescript: "^5.7.0"
 		}
@@ -1733,7 +1731,9 @@ function scanTags(html) {
 		});
 		i = j + 1;
 		if (!closing && RAW_TEXT_TAGS.has(name)) {
-			const close = html.toLowerCase().indexOf(`</${name}`, i);
+			const end = new RegExp(`</${name}`, "gi");
+			end.lastIndex = i;
+			const close = end.exec(html)?.index ?? -1;
 			i = close === -1 ? html.length : close;
 		}
 	}
@@ -3766,7 +3766,7 @@ const REDIRECT_STATUSES = [
 /** Whitespace, a control character or DEL anywhere in the string. */
 const hasControlOrSpace = (value) => [...value].some((char) => char.charCodeAt(0) <= 32 || char.charCodeAt(0) === 127);
 /** `/old/` and `/old` are one address in the directory build format. */
-function addressKey$1(path) {
+function addressKey$2(path) {
 	return path === "/" ? "/" : `${path.replace(/\/+$/, "")}/`;
 }
 /**
@@ -3777,7 +3777,7 @@ function addressKey$1(path) {
 function builtAddresses(routes, content) {
 	const out = /* @__PURE__ */ new Map();
 	const put = (path, routeId) => {
-		if (path !== null && !out.has(addressKey$1(path))) out.set(addressKey$1(path), routeId);
+		if (path !== null && !out.has(addressKey$2(path))) out.set(addressKey$2(path), routeId);
 	};
 	for (const route of routes) {
 		const pagePath = patternToPagePath(route.pattern);
@@ -3795,7 +3795,7 @@ function builtAddresses(routes, content) {
 	return out;
 }
 /** The decoded path for a literal Astro redirect key, or why `from` cannot be one. */
-function checkFrom(from) {
+function checkFrom(from, hostOnly = false) {
 	if (!from.startsWith("/") || from.startsWith("//")) return { reason: "from is not a site-root path" };
 	if (/[?#]/.test(from)) return { reason: "from has a query string or fragment — a static redirect matches the path only" };
 	let path;
@@ -3808,9 +3808,24 @@ function checkFrom(from) {
 	if (/[[\]]/.test(path)) return { reason: "from contains [ or ], which Astro reads as a route parameter" };
 	const segments = path.split("/").filter(Boolean);
 	if (segments.some((s) => s === "." || s === "..")) return { reason: "from contains a . or .. segment" };
-	if (/\.[a-z0-9]{1,5}$/i.test(segments.at(-1) ?? "")) return { reason: "from ends in a file name — the static build serves it as a directory, not at this address" };
+	if (!hostOnly && /\.[a-z0-9]{1,5}$/i.test(segments.at(-1) ?? "")) return { reason: "from ends in a file name — the static build serves it as a directory, not at this address" };
 	return { path };
 }
+/**
+* A path the build writes a file at: the emitter's own endpoints (robots,
+* llms.txt, every feed, @astrojs/sitemap's files), the 404 page, and the
+* directories of Astro's bundles and the legacy stylesheets. A host file
+* answers before the filesystem — a forced Netlify rule and every vercel.json
+* redirect — so a host-only rule here would shadow the file. `builtAddresses`
+* knows pages only. Compared without a trailing slash (a host file gets both
+* forms) and in lower case (Netlify matches rules case-insensitively).
+* WordPress's own `/sitemap.xml` and `/sitemap_index.xml` are not the build's:
+* a 301 from them is one a migration wants.
+*/
+function buildOutputFile(path) {
+	const p = (path.replace(/\/+$/, "") || "/").toLowerCase();
+	return p === "/robots.txt" || p === "/llms.txt" || p === "/404.html" || p.endsWith("/feed.xml") || /^\/sitemap-(?:index|\d+)\.xml$/.test(p) || /^\/(?:_astro|styles)(?:\/|$)/.test(p);
+}
 function checkTo(to) {
 	if (hasControlOrSpace(to)) return false;
 	if (to.startsWith("/")) return !to.startsWith("//");
@@ -3823,9 +3838,11 @@ function checkTo(to) {
 }
 /**
 * Split the rules into what `astro.config` serves and what the host has to.
-* `built` is `builtAddresses` of the emitted routes.
+* `built` is `builtAddresses` of the emitted routes. `hostOnly`: the rules go
+* to host files alone (`EmitInput.hostRedirects`), so the checks that hold
+* only for a static redirect page (a `from` naming a file) are left out.
 */
-function planRedirects(redirects, built) {
+function planRedirects(redirects, built, options = {}) {
 	const config = {};
 	const written = [];
 	const manual = [];
@@ -3849,16 +3866,20 @@ function planRedirects(redirects, built) {
 			skip(`status ${status} is not one of ${REDIRECT_STATUSES.join("/")}`);
 			continue;
 		}
-		const from = checkFrom(redirect.from);
+		const from = checkFrom(redirect.from, options.hostOnly);
 		if ("reason" in from) {
 			skip(from.reason);
 			continue;
 		}
+		if (options.hostOnly && buildOutputFile(from.path)) {
+			skip("from is a file the build writes — the host file would serve the redirect over it");
+			continue;
+		}
 		if (!checkTo(redirect.to)) {
 			skip("to is not a site-root path or an http(s) URL");
 			continue;
 		}
-		const key = addressKey$1(from.path);
+		const key = addressKey$2(from.path);
 		const owner = built.get(key);
 		if (owner !== void 0) {
 			skip(`the migrated site builds a page at ${key} (route ${owner}) — the page is kept`);
@@ -3880,7 +3901,7 @@ function planRedirects(redirects, built) {
 			} catch {
 				target = redirect.to;
 			}
-			if (addressKey$1(target) === key) {
+			if (addressKey$2(target) === key) {
 				skip("to is the same address as from");
 				continue;
 			}
@@ -3985,6 +4006,172 @@ function hostRedirectFiles(config, host) {
 	};
 }
 //#endregion
+//#region src/published.ts
+/**
+* Why an entry is not built, or null when it is. `now` is epoch ms. With
+* `requireStatus` an entry that carries no status is held back: the producer
+* said it passes every entry's status, so a missing one is a gap, not a
+* published entry.
+*/
+function holdReason(post, now, requireStatus = false) {
+	if (post.visibility !== void 0 && post.visibility !== "public") return "visibility";
+	if (post.status === void 0 && requireStatus) return "status_missing";
+	if (post.status !== void 0 && post.status !== "published") return "status";
+	if (post.publish_at === void 0) return null;
+	const at = Date.parse(post.publish_at);
+	if (Number.isNaN(at)) return "publish_at_invalid";
+	return at > now ? "scheduled" : null;
+}
+const bareHost = (host) => host.replace(/^www\./, "").toLowerCase();
+/** `/a/b` and `/a/b/` are one address. */
+const addressKey$1 = (path) => path === "/" ? "/" : `${path.replace(/\/+$/, "")}/`;
+/**
+* The held-back address an href points at, or null: a site-root path, or an
+* absolute URL on the site's own host (`www.` either way).
+*/
+function withheldTarget(href, gone, siteUrl) {
+	if (!gone.size) return null;
+	let site;
+	try {
+		site = siteUrl ? new URL(siteUrl) : void 0;
+	} catch {
+		site = void 0;
+	}
+	let url;
+	try {
+		url = new URL(href, site ?? "http://site.invalid");
+	} catch {
+		return null;
+	}
+	if (!(site ? bareHost(url.host) === bareHost(site.host) : url.host === "site.invalid") || !/^https?:$/.test(url.protocol)) return null;
+	let path = url.pathname;
+	try {
+		path = decodeURI(path);
+	} catch {}
+	return gone.has(addressKey$1(path)) ? path : null;
+}
+/**
+* The content with every unpublished entry removed — from its collection and
+* from the list pages that carry it as an item — and links to them unwrapped.
+* Content with nothing held back is returned as given.
+*/
+function publishedContent(routes, content, now, siteUrl, requireStatus = false) {
+	const withheld = [];
+	const keep = (collection) => (post) => {
+		const reason = holdReason(post, now, requireStatus);
+		if (!reason) return true;
+		withheld.push({
+			collection,
+			slug: post.slug,
+			...post.status ? { status: post.status } : {},
+			...post.visibility ? { visibility: post.visibility } : {},
+			...post.publish_at ? { publish_at: post.publish_at } : {},
+			reason
+		});
+		return false;
+	};
+	const collections = content.collections ? Object.fromEntries(Object.entries(content.collections).map(([name, posts]) => [name, posts.filter(keep(name))])) : void 0;
+	const isLive = (post) => holdReason(post, now, requireStatus) === null;
+	const posts = content.posts?.filter(content.collections?.["posts"] ? isLive : keep(DEFAULT_COLLECTION));
+	const queries = content.queries ? Object.fromEntries(Object.entries(content.queries).map(([id, pages]) => [id, pages.map((page) => page.items.every(isLive) ? page : {
+		...page,
+		items: page.items.filter(isLive)
+	})])) : void 0;
+	const listedOnly = Object.values(content.queries ?? {}).flat().flatMap((p) => p.items).some((item) => !isLive(item));
+	if (!withheld.length && !listedOnly) return {
+		content,
+		withheld,
+		links: [],
+		gone: /* @__PURE__ */ new Set()
+	};
+	const filtered = {
+		...content,
+		...posts ? { posts } : {},
+		...collections ? { collections } : {},
+		...queries ? { queries } : {}
+	};
+	const built = builtAddresses(routes, filtered);
+	const gone = /* @__PURE__ */ new Set();
+	for (const route of routes) {
+		const pagePath = patternToPagePath(route.pattern);
+		if (!pagePath || !pagePath.includes("[") || route.kind !== "single" && route.collection === void 0) continue;
+		const collection = route.collection ?? "posts";
+		for (const post of collectionItems(content, collection)) {
+			const path = entryPath(route.pattern, {
+				...post.params,
+				slug: post.slug
+			});
+			if (path && !isLive(post) && !built.has(addressKey$1(path))) gone.add(addressKey$1(path));
+		}
+	}
+	const links = [];
+	const unlink = (html, page) => {
+		if (!html || !gone.size) return html;
+		return html.replace(ANCHOR_RE, (anchor, double, single, inner) => {
+			const to = withheldTarget((double ?? single ?? "").replace(/&amp;/g, "&"), gone, siteUrl);
+			if (!to) return anchor;
+			links.push({
+				page,
+				href: to
+			});
+			return inner;
+		});
+	};
+	const unlinkPost = (post, page) => {
+		const body = unlink(post.body, page) ?? post.body;
+		const excerpt_html = unlink(post.excerpt_html, page);
+		return body === post.body && excerpt_html === post.excerpt_html ? post : {
+			...post,
+			body,
+			...excerpt_html !== void 0 ? { excerpt_html } : {}
+		};
+	};
+	const pageOf = (collection, post) => {
+		const route = routes.find((r) => (r.kind === "single" || r.collection !== void 0) && (r.collection ?? "posts") === collection);
+		return (route && entryPath(route.pattern, {
+			...post.params,
+			slug: post.slug
+		})) ?? `${collection}/${post.slug}`;
+	};
+	if (filtered.collections) filtered.collections = Object.fromEntries(Object.entries(filtered.collections).map(([name, list]) => [name, list.map((p) => unlinkPost(p, pageOf(name, p)))]));
+	if (filtered.posts) filtered.posts = filtered.posts.map((p) => unlinkPost(p, pageOf(DEFAULT_COLLECTION, p)));
+	if (filtered.queries) filtered.queries = Object.fromEntries(Object.entries(filtered.queries).map(([id, pages]) => [id, pages.map((page) => {
+		const route = routes.find((r) => r.query === id);
+		const at = (route && entryPath(route.pattern, page.params)) ?? `query ${id}`;
+		return {
+			...page,
+			items: page.items.map((item) => unlinkPost(item, at))
+		};
+	})]));
+	return {
+		content: filtered,
+		withheld,
+		links,
+		gone
+	};
+}
+const ANCHOR_RE = /<a\b[^>]*?\shref\s*=\s*(?:"([^"]*)"|'([^']*)')[^>]*>([\s\S]*?)<\/a\s*>/gi;
+/** The report lines for what was held back. */
+function withheldWarnings(withheld, links) {
+	const out = [];
+	if (withheld.length) {
+		const count = (reason) => withheld.filter((w) => w.reason === reason).length;
+		const parts = [
+			count("visibility") && `${count("visibility")} password-protected or private`,
+			count("status_missing") && `${count("status_missing")} with no status (options.requireStatus)`,
+			count("status") && `${count("status")} not published (draft, in review, rejected or archived)`,
+			count("scheduled") && `${count("scheduled")} scheduled for later — built by the first emit after their publish_at`,
+			count("publish_at_invalid") && `${count("publish_at_invalid")} with a publish_at that is not a date`
+		].filter(Boolean);
+		out.push(`unpublished: ${withheld.length} entries not built — ${parts.join("; ")}. They stay in the content store; EmitResult.withheld lists each`);
+	}
+	if (links.length) {
+		const sample = links.slice(0, 5).map((l) => `${l.href} (on ${l.page})`).join(", ");
+		out.push(`unpublished: ${links.length} links from published pages to unpublished entries kept as plain text — ${sample}${links.length > 5 ? " …" : ""}`);
+	}
+	return out;
+}
+//#endregion
 //#region src/seo-entry.ts
 /**
 * A plugin's unrendered template, in its own syntax: Yoast `%%title%%`,
@@ -4163,6 +4350,27 @@ function emitAstroProject(input) {
 			files[path] = content;
 		}
 	};
+	let now = Date.now();
+	if (input.options?.now !== void 0) {
+		const at = Date.parse(input.options.now);
+		if (Number.isNaN(at)) warnings.push(`options.now "${input.options.now}" is not a date — publish_at is compared with the time of this emit`);
+		else now = at;
+	}
+	const published = publishedContent(ir.routes, input.content ?? {}, now, ir.site.url, input.options?.requireStatus === true);
+	const content = published.content;
+	warnings.push(...withheldWarnings(published.withheld, published.links));
+	const withheldManual = [];
+	const toPublished = (rules) => rules?.filter((redirect) => {
+		const target = withheldTarget(redirect.to, published.gone, ir.site.url);
+		if (target) withheldManual.push({
+			redirect,
+			reason: `to ${target}, an entry that is not published — the build has no page there`
+		});
+		return !target;
+	});
+	const siteRedirects = toPublished(input.redirects);
+	const hostOnlyRedirects = toPublished(input.hostRedirects);
+	if (withheldManual.length) warnings.push(`unpublished: ${withheldManual.length} redirects point at unpublished entries — not written (EmitResult.redirects.manual has each)`);
 	const siteLang = ir.site.locales?.[0] ?? "en";
 	const linkable = ir.site.url ? linkSources(ir.routes, siteLang) : [];
 	const feedSource = input.options?.feed !== false ? linkable.find((s) => s.collection === DEFAULT_COLLECTION) : void 0;
@@ -4170,11 +4378,11 @@ function emitAstroProject(input) {
 	const archiveFeeds = feedSource ? archiveFeedSources(ir.routes, siteLang) : [];
 	const archiveFeedRoutes = new Set(archiveFeeds.map((a) => a.routeId));
 	if (!ir.site.url && (input.options?.feed !== false || input.options?.llms !== false)) warnings.push("site.url is empty — no RSS feed and no llms.txt are built; both name pages by absolute address");
-	const redirectPlan = input.redirects ? planRedirects(input.redirects, builtAddresses(ir.routes, input.content ?? {})) : void 0;
-	if (redirectPlan?.manual.length) warnings.push(`redirects: ${redirectPlan.manual.length} of ${input.redirects.length} rules not written to astro.config — set them up at the host (EmitResult.redirects.manual has each with its reason)`);
+	const redirectPlan = siteRedirects ? planRedirects(siteRedirects, builtAddresses(ir.routes, content)) : void 0;
+	if (redirectPlan?.manual.length) warnings.push(`redirects: ${redirectPlan.manual.length} of ${siteRedirects.length} rules not written to astro.config — set them up at the host (EmitResult.redirects.manual has each with its reason)`);
 	const seo = input.options?.seo !== false;
-	const noindex = noindexPaths(ir.routes, input.content ?? {});
-	const built = builtAddresses(ir.routes, input.content ?? {});
+	const noindex = noindexPaths(ir.routes, content);
+	const built = builtAddresses(ir.routes, content);
 	const sourceConfig = redirectPlan?.config ?? {};
 	const claimed = new Set(Object.keys(sourceConfig).map((from) => from.replace(/\/+$/, "").toLowerCase()));
 	const feedRules = [];
@@ -4189,7 +4397,7 @@ function emitAstroProject(input) {
 		});
 	};
 	if (feedSource) addFeedRule(FEED_REDIRECT_FROM, FEED_PATH);
-	for (const source of archiveFeeds) for (const page of input.content?.queries?.[source.query] ?? []) {
+	for (const source of archiveFeeds) for (const page of content.queries?.[source.query] ?? []) {
 		const address = entryPath(source.pattern, page.params);
 		if (address) addFeedRule(`${address}feed/`, `${address}feed.xml`);
 	}
@@ -4201,22 +4409,60 @@ function emitAstroProject(input) {
 	};
 	const hasRedirects = Object.keys(redirectConfig).length > 0;
 	add(scaffoldFiles(ir, input.options ?? {}, noindex, hasRedirects ? astroRedirectsConfig(sortedConfig(redirectConfig)) : null, input.runtime));
+	const hostOnlyPlan = hostOnlyRedirects ? planRedirects(hostOnlyRedirects, built, { hostOnly: true }) : void 0;
+	const hostOnlyConfig = {};
+	const hostOnlyRule = /* @__PURE__ */ new Map();
+	const hostOnlyManual = [...hostOnlyPlan?.manual ?? []];
+	if (hostOnlyPlan) {
+		const byFrom = new Map(hostOnlyPlan.written.map((rule) => [decodedPath(rule.from), rule]));
+		for (const [from, rule] of Object.entries(hostOnlyPlan.config)) {
+			const redirect = byFrom.get(from);
+			const key = from.replace(/\/+$/, "").toLowerCase();
+			if (claimed.has(key)) {
+				hostOnlyManual.push({
+					redirect,
+					reason: `another rule already redirects ${from}`
+				});
+				continue;
+			}
+			claimed.add(key);
+			hostOnlyConfig[from] = rule;
+			hostOnlyRule.set(from, redirect);
+		}
+	}
 	const feedOrder = new Map(feedRules.map((rule, index) => [decodedPath(rule.from), index]));
 	const feedKeys = Object.keys(feedPlan.config).toSorted((a, b) => (feedOrder.get(a) ?? 0) - (feedOrder.get(b) ?? 0));
 	const hostOrder = {
 		...sortedConfig(sourceConfig),
-		...Object.fromEntries(feedKeys.map((key) => [key, feedPlan.config[key]]))
+		...Object.fromEntries(feedKeys.map((key) => [key, feedPlan.config[key]])),
+		...sortedConfig(hostOnlyConfig)
 	};
-	const hostRedirects = hasRedirects ? hostRedirectFiles(hostOrder, input.options?.redirectHost) : void 0;
+	const hostRedirects = Object.keys(hostOrder).length ? hostRedirectFiles(hostOrder, input.options?.redirectHost) : void 0;
+	const hostOnly = (from) => hostOnlyRule.has(from);
+	for (const from of hostRedirects?.skipped ?? []) if (hostOnly(from)) hostOnlyManual.push({
+		redirect: hostOnlyRule.get(from),
+		reason: "from contains \":\" or \"*\", which host redirect files read as a pattern"
+	});
+	const namedHost = input.options?.redirectHost;
+	const hostOnlyOver = (hostRedirects?.over_limit ?? []).filter(hostOnly);
+	if (namedHost !== void 0) for (const from of hostOnlyOver) hostOnlyManual.push({
+		redirect: hostOnlyRule.get(from),
+		reason: `left out of ${hostRedirects.written.join(", ")} at its rule limit (${HOST_RULE_LIMIT / 2} rules) — a host-only rule has no meta-refresh page to fall back on`
+	});
+	else if (hostOnlyOver.length) warnings.push(`hostRedirects: ${hostOnlyOver.length} host-only rules not written to vercel.json at its rule limit (${HOST_RULE_LIMIT / 2} rules) — public/_redirects (Netlify) has them; on Vercel they are not served. Name the host (options.redirectHost) to have them reported as manual`);
+	const unservedHostOnly = new Set(hostOnlyManual.map((m) => m.redirect));
+	if (hostOnlyManual.length) warnings.push(`hostRedirects: ${hostOnlyManual.length} of ${hostOnlyRedirects.length} host-only rules not written — set them up at the host (EmitResult.redirects.manual has each with its reason)`);
 	if (hostRedirects) {
 		add(hostRedirects.files);
-		if (hostRedirects.over_limit.length) {
+		const overLimit = hostRedirects.over_limit.filter((from) => !hostOnly(from));
+		const skippedPatterns = hostRedirects.skipped.filter((from) => !hostOnly(from));
+		if (overLimit.length) {
 			const limitedFiles = hostRedirects.written.filter((f) => !f.includes("(netlify)")).join(", ");
-			const feedOver = hostRedirects.over_limit.filter((from) => from in feedPlan.config).length;
+			const feedOver = overLimit.filter((from) => from in feedPlan.config).length;
 			const which = feedOver ? ` (${feedOver} of them feed redirects — /feed/ and archive feeds come after the site's own rules)` : "";
-			warnings.push(`redirects: ${hostRedirects.over_limit.length} rules not written to ${limitedFiles}${which} — ${HOST_RULE_LIMIT / 2} rules (each path with and without its slash) fill Cloudflare Pages' 2,000 static and Vercel's 2,048 redirect limit. They are served by the meta-refresh fallback only; move them to the host's dynamic rules for a real status`);
+			warnings.push(`redirects: ${overLimit.length} rules not written to ${limitedFiles}${which} — ${HOST_RULE_LIMIT / 2} rules (each path with and without its slash) fill Cloudflare Pages' 2,000 static and Vercel's 2,048 redirect limit. They are served by the meta-refresh fallback only; move them to the host's dynamic rules for a real status`);
 		}
-		if (hostRedirects.skipped.length) warnings.push(`redirects: ${hostRedirects.skipped.length} rules contain ":" or "*", which host redirect files read as patterns — served by the meta-refresh fallback only: ${hostRedirects.skipped.join(", ")}`);
+		if (skippedPatterns.length) warnings.push(`redirects: ${skippedPatterns.length} rules contain ":" or "*", which host redirect files read as patterns — served by the meta-refresh fallback only: ${skippedPatterns.join(", ")}`);
 	}
 	if (input.options?.trailingSlash === false && (input.options.redirectHost ?? "vercel") === "vercel") {
 		const vercel = files["vercel.json"] ? JSON.parse(files["vercel.json"]) : {};
@@ -4241,7 +4487,7 @@ function emitAstroProject(input) {
 	const bodyMarkersByFamily = /* @__PURE__ */ new Map();
 	for (const route of ir.routes) {
 		if (route.kind !== "single" && route.collection === void 0) continue;
-		const posts = collectionItems(input.content ?? {}, route.collection ?? "posts");
+		const posts = collectionItems(content, route.collection ?? "posts");
 		const ids = bodyMarkersByFamily.get(route.family) ?? /* @__PURE__ */ new Set();
 		for (const post of posts) for (const id of componentMarkers(post.body)) ids.add(id);
 		if (ids.size) bodyMarkersByFamily.set(route.family, ids);
@@ -4250,7 +4496,7 @@ function emitAstroProject(input) {
 	const queryBound = /* @__PURE__ */ new Set();
 	for (const family of ir.families) for (const placement of family.components ?? []) {
 		if (!placement.query) continue;
-		const pages = input.content?.queries?.[placement.query];
+		const pages = content.queries?.[placement.query];
 		if (!pages) {
 			warnings.push(`family ${family.id}: placement "${placement.component}" binds query "${placement.query}", which is not in input.content.queries — binding dropped, region left as cloned markup`);
 			continue;
@@ -4283,23 +4529,23 @@ function emitAstroProject(input) {
 		for (const ref of refs ?? []) if (!providedCss.has(ref.split("/").pop() ?? ref)) warnings.push(`${owner}: css file "${ref}" not provided in input.css`);
 	};
 	for (const family of ir.families) missingCss(family.css.files, `family ${family.id}`);
-	const allPosts = [...input.content?.posts ?? [], ...Object.values(input.content?.collections ?? {}).flat()];
+	const allPosts = [...content.posts ?? [], ...Object.values(content.collections ?? {}).flat()];
 	for (const post of allPosts) missingCss(post.css, `post ${post.slug}`);
-	for (const [queryId, queryPages] of Object.entries(input.content?.queries ?? {})) for (const qp of queryPages) missingCss(qp.css, `query ${queryId}`);
-	const trailOwners = [...Object.entries(input.content?.collections ?? {}), ...input.content?.posts ? [[DEFAULT_COLLECTION, input.content.posts]] : []];
+	for (const [queryId, queryPages] of Object.entries(content.queries ?? {})) for (const qp of queryPages) missingCss(qp.css, `query ${queryId}`);
+	const trailOwners = [...Object.entries(content.collections ?? {}), ...content.posts ? [[DEFAULT_COLLECTION, content.posts]] : []];
 	for (const [name, posts] of trailOwners) {
 		const bad = (posts ?? []).filter((p) => badTrail(p.breadcrumbs)).length;
 		if (bad) warnings.push(`collection ${name}: ${bad} breadcrumb trails dropped — every crumb needs a name and a site-root-relative path`);
 		const badLd = (posts ?? []).filter((p) => badSchema(p.schema)).length;
 		if (badLd) warnings.push(`collection ${name}: ${badLd} schema values are not JSON-LD objects — those pages print the generated structured data instead`);
 	}
-	for (const [queryId, queryPages] of Object.entries(input.content?.queries ?? {})) {
+	for (const [queryId, queryPages] of Object.entries(content.queries ?? {})) {
 		const bad = queryPages.filter((qp) => badTrail(qp.breadcrumbs)).length;
 		if (bad) warnings.push(`query ${queryId}: ${bad} breadcrumb trails dropped — every crumb needs a name and a site-root-relative path`);
 		const badLd = queryPages.filter((qp) => badSchema(qp.schema)).length;
 		if (badLd) warnings.push(`query ${queryId}: ${badLd} schema values are not JSON-LD objects — those pages print the generated structured data instead`);
 	}
-	let routeContent = input.content ?? {};
+	let routeContent = content;
 	if (seo) {
 		const alternates = withAlternates(ir.routes, routeContent, lang);
 		routeContent = alternates.content;
@@ -4354,8 +4600,8 @@ function emitAstroProject(input) {
 		if (uncovered.length) warnings.push(`ui-strings: no dictionary ${declared ? "declared" : "declared in options.uiStrings.locales"} for ${uncovered.join(", ")} — comments and forms on those pages show English text unless ${stringsDir ?? ".contentrain/content/site/ui-strings"}/{locale}.json exists at build`);
 	}
 	if ((ir.components ?? []).some((c) => isRuntimeImplemented(c, input.runtime) && c.type === "comments")) {
-		const collections = { ...input.content?.collections };
-		if (input.content?.posts && !collections["posts"]) collections[DEFAULT_COLLECTION] = input.content.posts;
+		const collections = { ...content.collections };
+		if (content.posts && !collections["posts"]) collections[DEFAULT_COLLECTION] = content.posts;
 		for (const [name, posts] of Object.entries(collections)) {
 			const unbound = posts.filter((p) => !p.entry).length;
 			if (unbound) warnings.push(`collection ${name}: ${unbound} of ${posts.length} posts carry no entry address — the comments component renders nothing on those pages`);
@@ -4381,11 +4627,19 @@ function emitAstroProject(input) {
 	return {
 		files,
 		warnings,
-		...redirectPlan ? { redirects: {
-			written: redirectPlan.written,
-			manual: redirectPlan.manual,
+		...redirectPlan || hostOnlyPlan ? { redirects: {
+			written: [...redirectPlan?.written ?? [], ...[...hostOnlyRule.values()].filter((rule) => !unservedHostOnly.has(rule))],
+			manual: [
+				...redirectPlan?.manual ?? [],
+				...hostOnlyManual,
+				...withheldManual
+			],
 			host_files: hostRedirects?.written ?? [],
-			host_over_limit: hostRedirects?.over_limit ?? []
+			host_over_limit: (hostRedirects?.over_limit ?? []).filter((from) => !hostOnly(from) || namedHost === void 0)
+		} } : {},
+		...published.withheld.length || published.links.length ? { withheld: {
+			entries: published.withheld,
+			links: published.links
 		} } : {}
 	};
 }
@@ -4409,6 +4663,6 @@ async function writeEmit(result, dir) {
 	await Promise.all(Object.entries(result.files).map(([path, content]) => writeFile(join(dir, path), content, "utf8")));
 }
 //#endregion
-export { EMBED_TS, FEED_ITEMS, FEED_PATH, LLMS_LINKS, REDIRECT_STATUSES, RUNTIME_IMPLEMENTED, SEO_COMPONENT, UI_STRINGS_DIR, UI_STRINGS_MODEL, UI_STRING_DEFAULTS, astroRedirectsConfig, balanceWarning, bodySeoLeaks, builtAddresses, checkBalance, componentMarkers, emitAstroProject, entryPath, hostRedirectFiles, isRuntimeImplemented, linkSources, noindexPaths, pascalCase, patternToPagePath, planRedirects, publisherIdOf, rewriteFeedLinks, seoFromRawEntry, stableJson, stripSeoTags, websiteIdOf, withAlternates, wrapLegacyCss, writeEmit };
+export { EMBED_TS, FEED_ITEMS, FEED_PATH, LLMS_LINKS, REDIRECT_STATUSES, RUNTIME_IMPLEMENTED, SEO_COMPONENT, UI_STRINGS_DIR, UI_STRINGS_MODEL, UI_STRING_DEFAULTS, astroRedirectsConfig, balanceWarning, bodySeoLeaks, builtAddresses, checkBalance, componentMarkers, emitAstroProject, entryPath, holdReason, hostRedirectFiles, isRuntimeImplemented, linkSources, noindexPaths, pascalCase, patternToPagePath, planRedirects, publishedContent, publisherIdOf, rewriteFeedLinks, seoFromRawEntry, stableJson, stripSeoTags, websiteIdOf, withAlternates, wrapLegacyCss, writeEmit };
 
 //# sourceMappingURL=index.mjs.map