@contentrain/emitter-astro 0.14.5 → 0.16.0

package/dist/index.mjs

@@ -1,8 +1,296 @@
-import { CHROME_BODY_SLOT, CHROME_COMPONENT_CLOSE, CHROME_COMPONENT_OPEN, DICTIONARY_TITLE_FIELD, LEGACY_CSS_LAYER } from "@contentrain/types";
+import { CHROME_BODY_SLOT, CHROME_COMPONENT_CLOSE, CHROME_COMPONENT_OPEN, DICTIONARY_TITLE_FIELD, LEGACY_CSS_LAYER, SEO_PROVIDERS } from "@contentrain/types";
 //#region src/types.ts
 /** Default collection name when a `single` route does not name one. */
 const DEFAULT_COLLECTION = "posts";
 //#endregion
+//#region src/images.ts
+const DEFAULT_IMAGE_WIDTHS = [
+	480,
+	768,
+	1024,
+	1600
+];
+function imagesEnabled(options) {
+	return options.images?.enabled !== false;
+}
+/**
+* The hosts the site may optimize: the producer's list plus the runtime host,
+* because migrated media is rehosted there. Deduplicated, stable order.
+*/
+function imagePatterns(options, runtime) {
+	const out = [...options.images?.remotePatterns ?? []];
+	if (runtime?.base_url) try {
+		const url = new URL(runtime.base_url);
+		out.push({
+			protocol: url.protocol === "http:" ? "http" : "https",
+			hostname: url.hostname
+		});
+	} catch {}
+	const seen = /* @__PURE__ */ new Set();
+	return out.filter((p) => {
+		const key = `${p.protocol ?? "https"}|${p.hostname}|${p.pathname ?? ""}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+/** The `image` block for astro.config.mjs — Astro enforces the same allow-list. */
+function astroImageConfig(patterns) {
+	if (patterns.length === 0) return null;
+	return `  image: { remotePatterns: [${patterns.map((p) => {
+		const parts = [`protocol: ${JSON.stringify(p.protocol ?? "https")}`, `hostname: ${JSON.stringify(p.hostname)}`];
+		if (p.pathname) parts.push(`pathname: ${JSON.stringify(`${p.pathname.replace(/\/?$/, "/")}**`)}`);
+		return `{ ${parts.join(", ")} }`;
+	}).join(", ")}] },`;
+}
+const IMAGES_TS = `// Emitted by @contentrain/emitter-astro — image pass over content HTML.
+// Pure: the optimizer is injected (see optimize-images.ts), so this file has
+// no Astro dependency and never breaks a page — an image the optimizer
+// cannot handle keeps its original markup.
+
+export interface OptimizedImage {
+  src: string
+  srcset?: string
+  width?: number
+  height?: number
+}
+
+export type ImageOptimizer = (
+  src: string,
+  hints: { width?: number; height?: number },
+) => Promise<OptimizedImage | null>
+
+// Quoted attribute values may hold a ">" (alt="a > b"), so a tag ends at the
+// first ">" outside quotes. An unquoted value may hold a quote (alt=don't),
+// which a browser reads as part of the value; there the quote-aware match
+// would run on to the next quote and swallow the markup after the tag. A
+// match that reaches a "<" is that case, and the tag is read up to its first
+// ">" instead.
+const IMG_START = /<img\\b/gi
+const IMG_QUOTED = /<img\\b(?:[^>"']|"[^"]*"|'[^']*')*>/y
+const IMG_PLAIN = /<img\\b[^>]*>/y
+// An unquoted value runs to whitespace or ">", quotes included, as a browser reads it.
+const ATTR = /([^\\s=/>]+)(?:\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+)))?/g
+
+/** Every <img> tag in the html, with where it starts. */
+function imgTags(html: string): Array<{ start: number; tag: string }> {
+  const found: Array<{ start: number; tag: string }> = []
+  for (const open of html.matchAll(IMG_START)) {
+    const start = open.index ?? 0
+    if (found.length && start < found[found.length - 1]!.start + found[found.length - 1]!.tag.length) continue
+    IMG_QUOTED.lastIndex = start
+    let tag = IMG_QUOTED.exec(html)?.[0]
+    if (tag === undefined || tag.includes('<', 1)) {
+      IMG_PLAIN.lastIndex = start
+      tag = IMG_PLAIN.exec(html)?.[0]
+    }
+    if (tag !== undefined) found.push({ start, tag })
+  }
+  return found
+}
+const SKIP_EXT = /\\.(svg|gif)(?:$|[?#])/i
+
+// Attribute values are kept as the source wrote them (entities and all) and
+// written back unchanged; only values this pass sets are escaped. Reading a
+// value decodes it: a WordPress src like "photo.jpg?w=800&amp;ssl=1" is the
+// URL "photo.jpg?w=800&ssl=1".
+function parseAttrs(tag: string): Array<[string, string | null]> {
+  const inner = tag.replace(/^<img\\b/i, '').replace(/\\/?>$/, '')
+  const attrs: Array<[string, string | null]> = []
+  for (const m of inner.matchAll(ATTR)) {
+    const name = m[1]
+    if (!name) continue
+    // Written back double-quoted, so a double quote inside another form is escaped.
+    const value = m[2] ?? (m[3] ?? m[4])?.replace(/"/g, '&quot;')
+    attrs.push([name, value === undefined ? null : value])
+  }
+  return attrs
+}
+
+const NAMED: Record<string, string> = { amp: '&', quot: '"', apos: "'", lt: '<', gt: '>' }
+
+function decodeAttr(value: string): string {
+  return value.replace(/&(?:#(\\d+)|#x([0-9a-f]+)|([a-z]+));/gi, (entity, dec, hex, name) => {
+    if (dec || hex) {
+      const code = dec ? Number(dec) : parseInt(hex, 16)
+      return code > 0 && code <= 0x10ffff ? String.fromCodePoint(code) : entity
+    }
+    return NAMED[name.toLowerCase()] ?? entity
+  })
+}
+
+function escapeAttr(value: string): string {
+  return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;')
+}
+
+function serialize(attrs: Array<[string, string | null]>): string {
+  return \`<img\${attrs.map(([n, v]) => (v === null ? \` \${n}\` : \` \${n}="\${v}"\`)).join('')}>\`
+}
+
+function positiveInt(value: string | null | undefined): number | undefined {
+  if (!value) return undefined
+  const n = Number(value)
+  return Number.isInteger(n) && n > 0 ? n : undefined
+}
+
+/**
+ * Rewrite every <img> in the html. The first image is eager with high fetch
+ * priority; the rest are lazy. Images the optimizer accepts get its src,
+ * srcset and size. An existing loading or decoding attribute is respected.
+ */
+export async function rewriteImages(
+  html: string,
+  optimize: ImageOptimizer,
+  options: { sizes: string },
+): Promise<string> {
+  const found = imgTags(html)
+  if (!found.length) return html
+  const replacements: string[] = []
+  for (let index = 0; index < found.length; index++) {
+    const tag = found[index]!.tag
+    const attrs = parseAttrs(tag)
+    const get = (name: string) => {
+      const raw = attrs.find(([n]) => n.toLowerCase() === name)?.[1]
+      return raw == null ? raw : decodeAttr(raw)
+    }
+    const has = (name: string) => attrs.some(([n]) => n.toLowerCase() === name)
+    const set = (name: string, value: string) => {
+      const i = attrs.findIndex(([n]) => n.toLowerCase() === name)
+      if (i >= 0) attrs[i] = [attrs[i]![0], escapeAttr(value)]
+      else attrs.push([name, escapeAttr(value)])
+    }
+    const remove = (name: string) => {
+      const i = attrs.findIndex(([n]) => n.toLowerCase() === name)
+      if (i >= 0) attrs.splice(i, 1)
+    }
+
+    if (!has('loading')) {
+      set('loading', index === 0 ? 'eager' : 'lazy')
+      if (index === 0 && !has('fetchpriority')) set('fetchpriority', 'high')
+    }
+    if (!has('decoding')) set('decoding', 'async')
+
+    const src = get('src')
+    const keep = has('data-cr-keep') || !src || src.startsWith('data:') || SKIP_EXT.test(src)
+    if (!keep) {
+      try {
+        const result = await optimize(src, { width: positiveInt(get('width')), height: positiveInt(get('height')) })
+        if (result) {
+          set('src', result.src)
+          if (result.srcset) {
+            set('srcset', result.srcset)
+            if (!has('sizes')) set('sizes', options.sizes)
+          } else {
+            // The source's own srcset (WordPress's size variants) would win
+            // over the optimized src in every browser that reads srcset.
+            remove('srcset')
+            remove('sizes')
+          }
+          if (result.width && result.height && !has('width') && !has('height')) {
+            set('width', String(result.width))
+            set('height', String(result.height))
+          }
+        }
+      }
+      catch {
+        // Keep the original image: a failed optimization must not cost the page its picture.
+      }
+    }
+    replacements.push(serialize(attrs))
+  }
+  let out = ''
+  let at = 0
+  found.forEach(({ start, tag }, i) => {
+    out += html.slice(at, start) + replacements[i]
+    at = start + tag.length
+  })
+  return out + html.slice(at)
+}
+`;
+function optimizeImagesTs(patterns, widths, sizes) {
+	return `// Emitted by @contentrain/emitter-astro — binds the image pass to astro:assets.
+// Only hosts on this list are optimized; Astro enforces the same list
+// (image.remotePatterns in astro.config.mjs). Everything else keeps its URL
+// and still gets lazy loading and async decoding (see images.ts).
+import { getImage } from 'astro:assets'
+import { rewriteImages } from './images'
+
+const PATTERNS: Array<{ protocol: string; hostname: string; pathname?: string }> = ${JSON.stringify(patterns.map((p) => ({
+		protocol: p.protocol ?? "https",
+		hostname: p.hostname,
+		...p.pathname ? { pathname: p.pathname } : {}
+	})))}
+const WIDTHS = ${JSON.stringify(widths.toSorted((a, b) => a - b))}
+const SIZES = ${JSON.stringify(sizes)}
+
+// Astro downloads a remote image when the build writes its assets — after
+// this pass, outside its error handling — and one image that does not answer
+// 200 fails the whole astro build. So an image is only handed to getImage()
+// once it answered with an image here; anything else keeps its original URL.
+// One check per URL per build.
+const CHECK_TIMEOUT_MS = 10_000
+const checked = new Map<string, Promise<boolean>>()
+
+async function answersWithImage(src: string, method: 'HEAD' | 'GET'): Promise<boolean | null> {
+  try {
+    const res = await fetch(src, { method, redirect: 'follow', signal: AbortSignal.timeout(CHECK_TIMEOUT_MS) })
+    if (method === 'GET') await res.body?.cancel()
+    // Some hosts refuse HEAD; ask again with GET.
+    if (method === 'HEAD' && (res.status === 405 || res.status === 501 || res.status === 403)) return null
+    return res.ok && (res.headers.get('content-type') ?? '').toLowerCase().startsWith('image/')
+  }
+  catch {
+    return method === 'HEAD' ? null : false
+  }
+}
+
+function reachable(src: string): Promise<boolean> {
+  let pending = checked.get(src)
+  if (!pending) {
+    pending = answersWithImage(src, 'HEAD').then((ok) => ok ?? answersWithImage(src, 'GET').then((retry) => retry === true))
+    checked.set(src, pending)
+  }
+  return pending
+}
+
+function allowed(src: string): boolean {
+  let url: URL
+  try {
+    url = new URL(src)
+  }
+  catch {
+    return false
+  }
+  return PATTERNS.some((p) =>
+    url.protocol === \`\${p.protocol}:\`
+    && (p.hostname.startsWith('*.') ? url.hostname.endsWith(p.hostname.slice(1)) : url.hostname === p.hostname)
+    && (!p.pathname || url.pathname.startsWith(p.pathname)))
+}
+
+export async function optimizeHtmlImages(html: string): Promise<string> {
+  if (!html.includes('<img')) return html
+  return rewriteImages(html, async (src, hints) => {
+    if (!allowed(src) || !(await reachable(src))) return null
+    const sized = hints.width !== undefined && hints.height !== undefined
+    const widths = WIDTHS.filter((w) => hints.width === undefined || w <= hints.width)
+    const image = await getImage({
+      src,
+      format: 'webp',
+      ...(sized ? { width: hints.width, height: hints.height } : { inferSize: true }),
+      ...(widths.length ? { widths } : {}),
+    })
+    const width = Number(image.attributes.width)
+    const height = Number(image.attributes.height)
+    return {
+      src: image.src,
+      srcset: image.srcSet.attribute || undefined,
+      ...(width > 0 && height > 0 ? { width, height } : {}),
+    }
+  }, { sizes: SIZES })
+}
+`;
+}
+//#endregion
 //#region src/util.ts
 /** "f-archive" → "FArchive", "posts" → "Posts" — Astro component file names. */
 function pascalCase(id) {
@@ -43,11 +331,376 @@ function stableJson(value) {
 	return `${JSON.stringify(sortDeep(value), null, 2)}\n`;
 }
 //#endregion
+//#region src/pages.ts
+function routeFiles(route, family, content, siteLocale, seo = true, archiveFeed = false) {
+	const warnings = [];
+	const files = {};
+	const pagePath = patternToPagePath(route.pattern);
+	if (!pagePath) return {
+		files,
+		warnings: [`route ${route.id}: pattern "${route.pattern}" cannot be expressed as an Astro page — skipped`]
+	};
+	if (!family) return {
+		files,
+		warnings: [`route ${route.id}: family "${route.family}" not found — skipped`]
+	};
+	const layout = pascalCase(family.id);
+	const depth = pagePath.split("/").length - 1;
+	const up = "../".repeat(depth + 1) || "../";
+	const hasParams = pagePath.includes("[");
+	const restAt = restParamIndex(pagePath);
+	if (restAt !== -1 && restAt !== pagePath.split("/").length - 1) warnings.push(`route ${route.id}: rest parameter is not the final segment of "${route.pattern}" — Astro matches rest parameters greedily; verify this route resolves`);
+	if (route.kind === "single" || route.collection !== void 0) {
+		const collection = route.collection ?? "posts";
+		const posts = collectionItems(content, collection);
+		if (!posts.length) warnings.push(`route ${route.id}: collection "${collection}" has no items — page emitted, data file empty`);
+		files[`src/data/${collection}.json`] = stableJson(posts);
+		files[`src/pages/${pagePath}`] = singlePage(route, layout, up, collection, siteLocale, hasParams, seo);
+		return {
+			files,
+			warnings
+		};
+	}
+	const queryPages = route.query ? content.queries?.[route.query] ?? [] : [];
+	if (route.query) {
+		if (!queryPages.length) warnings.push(`route ${route.id}: query "${route.query}" has no data — page emitted, data file empty`);
+		if (queryPages.some((p) => !p.item_template && !p.sections?.length)) warnings.push(`route ${route.id}: item template missing on some pages — plain fallback list rendered (not fidelity)`);
+		files[`src/data/queries/${route.query}.json`] = stableJson(queryPages);
+		files[`src/pages/${pagePath}`] = listPage(route, layout, up, hasParams, siteLocale, seo, archiveFeed);
+		return {
+			files,
+			warnings
+		};
+	}
+	files[`src/pages/${pagePath}`] = staticPage(route, layout, up, hasParams, warnings, siteLocale, seo);
+	return {
+		files,
+		warnings
+	};
+}
+/** Items of a named collection; `posts` also accepts the `content.posts` shorthand. */
+function collectionItems(content, collection) {
+	const named = content.collections?.[collection];
+	if (named) return named;
+	return collection === "posts" ? content.posts ?? [] : [];
+}
+function singlePage(route, layout, up, collection, siteLocale, hasParams, seo) {
+	const locale = JSON.stringify(route.locale ?? siteLocale);
+	return `---
+// Route: ${route.id} (${route.pattern}) — collection: ${collection} — emitted by @contentrain/emitter-astro
+import Layout from '${up}layouts/${layout}.astro'
+import data from '${up}data/${collection}.json'
+import { postMarks${seo ? ", postSeo" : ""}, type EmittedPost } from '${up}lib/fill'
+
+${hasParams ? `export function getStaticPaths() {
+  // The JSON is data; its contract is EmittedPost. Inferring the type from the
+  // file would type only the fields this site happens to carry, and "astro
+  // check" (which the build runs first) would then reject post.params on a site
+  // whose permalinks need none. The cast lives INSIDE getStaticPaths because
+  // Astro hoists this function: it sees imports, not the component scope.
+  const posts = data as EmittedPost[]
+  // A post carries its own route parameters (date parts of a dated permalink,
+  // a post id) — using the template post's would send every other post to the
+  // wrong address.
+  return posts.map((post) => ({ params: { ...(post.params ?? {}), slug: post.slug }, props: { post } }))
+}
+type Props = { post: EmittedPost }
+const { post } = Astro.props as Props` : `const posts = data as EmittedPost[]
+if (posts.length !== 1) throw new Error(${JSON.stringify(`Static content route requires exactly one entry: ${route.id}`)})
+const post = posts[0]!`}
+---
+<Layout
+  title={post.title}
+  marks={postMarks(post)}
+  body={post.body}
+  css={post.css ?? []}
+  lang={post.locale ?? ${locale}}
+  entry={post.entry}${seo ? `
+  seo={postSeo(post${route.kind === "page" ? ", 'page'" : ""})}` : ""}
+/>
+`;
+}
+function listPage(route, layout, up, hasParams, siteLocale, seo, archiveFeed = false) {
+	const locale = JSON.stringify(route.locale ?? siteLocale);
+	const routeTitle = route.title === void 0 ? `''` : JSON.stringify(route.title);
+	const paths = hasParams ? `export function getStaticPaths() {
+  const pages = data as EmittedQueryPage[]
+  return pages.map((page) => ({ params: page.params, props: { page } }))
+}
+type Props = { page: EmittedQueryPage }
+const { page } = Astro.props as Props` : `const page = (data as EmittedQueryPage[])[0] ?? { params: {}, items: [], title: undefined }`;
+	return `---
+// Route: ${route.id} (${route.pattern}) — emitted by @contentrain/emitter-astro
+import Layout from '${up}layouts/${layout}.astro'
+import data from '${up}data/queries/${route.query}.json'
+import { ${archiveFeed && seo ? "entryAddress, " : ""}renderQueryPage, type EmittedQueryPage } from '${up}lib/fill'
+
+${paths}
+// A list renders in sections (a big card then a grid) — one template is the
+// single-section case. Without a template at all it falls back to a plain list
+// and the emitter has already warned: silence would read as fidelity.
+const content = renderQueryPage(page)
+// Route params carry slugs; page marks carry what the chrome needs to SHOW
+// (a term's display name, description, count).
+const marks = { ...page.params, ...(page.marks ?? {}) }
+const title = page.title ?? ${routeTitle}
+---
+<Layout
+  title={title || String(marks.term_name ?? page.params.term ?? '')}
+  marks={marks}
+  body={content}
+  css={page.css ?? []}
+  lang={${locale}}${seo ? `
+  seo={{ description: page.description, image: page.image, imageMeta: page.image_meta, canonical: page.canonical, breadcrumbs: page.breadcrumbs, noindex: page.noindex, nofollow: page.nofollow, openGraph: page.open_graph, twitter: page.twitter, schema: page.schema, profile: page.profile,${archiveFeed ? ` feed: { path: (entryAddress(${JSON.stringify(route.pattern)}, page.params) ?? '/') + 'feed.xml', title: title || undefined },` : ""} type: 'website', pageType: 'CollectionPage' }}` : ""}
+/>
+`;
+}
+function staticPage(route, layout, up, hasParams, warnings, siteLocale, seo) {
+	if (hasParams) warnings.push(`route ${route.id}: parameterized route without a query — emitted with empty paths`);
+	const paths = hasParams ? `export function getStaticPaths() {
+  return []
+}
+` : "";
+	return `---
+// Route: ${route.id} (${route.pattern}) — emitted by @contentrain/emitter-astro
+import Layout from '${up}layouts/${layout}.astro'
+${paths}---
+<Layout title=${JSON.stringify(route.title ?? "")} marks={{}} lang={${JSON.stringify(route.locale ?? siteLocale)}}${seo ? ` seo={{ type: 'website' }}` : ""} />
+`;
+}
+/** Share a catchall while preserving the original editable collections. */
+function sharedCollectionPage(routes, content, siteLocale, seo = true) {
+	const pattern = routes[0]?.pattern;
+	if (!pattern || routes.length < 2 || !/^\/(?:[^:*]+\/)*:slug\*$/.test(pattern) || routes.some((r) => r.pattern !== pattern || r.query || r.kind !== "single" && !r.collection)) return void 0;
+	const seen = /* @__PURE__ */ new Set();
+	for (const route of routes) for (const post of collectionItems(content, route.collection ?? "posts")) {
+		let key;
+		try {
+			key = decodeURIComponent(post.slug).replace(/\/+$/, "");
+		} catch {
+			return;
+		}
+		if (seen.has(key)) return void 0;
+		seen.add(key);
+	}
+	const up = "../".repeat(patternToPagePath(pattern).split("/").length);
+	return `---
+// Shared collection routes: ${routes.map((r) => r.id).join(", ")}
+${routes.map((r, i) => `import Layout${i} from '${up}layouts/${pascalCase(r.family)}.astro'\nimport data${i} from '${up}data/${r.collection ?? "posts"}.json'`).join("\n")}
+import { postMarks${seo ? ", postSeo" : ""}, type EmittedPost } from '${up}lib/fill'
+export function getStaticPaths() {
+  const sources = [${routes.map((_, i) => `data${i}`).join(", ")}] as EmittedPost[][]
+  const seen = new Set<string>()
+  return sources.flatMap((posts, routeIndex) => posts.map(post => {
+    const key = decodeURIComponent(post.slug).replace(/\\/+$/, '')
+    if (seen.has(key)) throw new Error('Route collision in shared collections: ' + post.slug)
+    seen.add(key)
+    return { params: { ...(post.params ?? {}), slug: post.slug }, props: { post, routeIndex } }
+  }))
+}
+const { post, routeIndex } = Astro.props as { post: EmittedPost, routeIndex: number }
+const layouts = [${routes.map((_, i) => `Layout${i}`).join(", ")}]
+const locales = ${JSON.stringify(routes.map((r) => r.locale ?? siteLocale))}
+const kinds = ${JSON.stringify(routes.map((r) => r.kind === "page" ? "page" : "post"))} as Array<'post' | 'page'>
+const Layout = layouts[routeIndex]!
+---
+<Layout title={post.title} marks={postMarks(post)} body={post.body}
+  css={post.css ?? []} lang={post.locale ?? locales[routeIndex]} entry={post.entry}${seo ? " seo={postSeo(post, kinds[routeIndex])}" : ""} />
+`;
+}
+//#endregion
+//#region src/alternates.ts
+/**
+* The path Astro builds for a route pattern and a set of parameters, in the
+* directory format the scaffold configures (`/en/hello/`). Null when a
+* parameter has no value — that page has no address to name.
+*/
+function entryPath(pattern, params) {
+	const segments = pattern.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
+	if (!segments.length) return "/";
+	const out = [];
+	for (const segment of segments) {
+		if (!segment.startsWith(":")) {
+			out.push(segment);
+			continue;
+		}
+		const value = params[segment.slice(1).replace(/\*$/, "")]?.replace(/^\/+|\/+$/g, "");
+		if (!value) return null;
+		out.push(value);
+	}
+	return `/${out.join("/")}/`;
+}
+const byLangTag = (a, b) => a.lang < b.lang ? -1 : a.lang > b.lang ? 1 : 0;
+/**
+* Attach `alternates` to every entry that has translations on the site.
+*
+* The language of a page is the one its `<html lang>` gets: the post's own
+* locale, else its route's, else the site's. A site with one language has no
+* alternates and nothing is attached.
+*/
+function withAlternates(routes, content, siteLocale) {
+	const warnings = [];
+	const placements = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		if (route.kind !== "single" && route.collection === void 0) continue;
+		const pagePath = patternToPagePath(route.pattern);
+		if (!pagePath) continue;
+		const collection = route.collection ?? "posts";
+		const posts = collectionItems(content, collection);
+		if (!pagePath.includes("[") && posts.length !== 1) continue;
+		for (const post of posts) {
+			const list = placements.get(post) ?? [];
+			list.push({
+				lang: post.locale ?? route.locale ?? siteLocale,
+				path: entryPath(route.pattern, {
+					...post.params,
+					slug: post.slug
+				}),
+				key: post.entry ? JSON.stringify([post.entry.model_id, post.entry.entry_id]) : void 0,
+				collection
+			});
+			placements.set(post, list);
+		}
+	}
+	if (new Set([...placements.values()].flat().map((p) => p.lang)).size < 2) return {
+		content,
+		warnings
+	};
+	const groups = /* @__PURE__ */ new Map();
+	const unkeyed = /* @__PURE__ */ new Map();
+	const ambiguous = /* @__PURE__ */ new Map();
+	for (const [post, list] of placements) {
+		const first = list[0];
+		if (list.length > 1 || first.path === null) {
+			ambiguous.set(first.collection, (ambiguous.get(first.collection) ?? 0) + 1);
+			continue;
+		}
+		if (!first.key) {
+			unkeyed.set(first.collection, (unkeyed.get(first.collection) ?? 0) + 1);
+			continue;
+		}
+		const group = groups.get(first.key) ?? [];
+		group.push({
+			post,
+			lang: first.lang,
+			path: first.path
+		});
+		groups.set(first.key, group);
+	}
+	for (const [collection, count] of unkeyed) warnings.push(`collection ${collection}: ${count} posts carry no entry address — hreflang cannot link them to their translations`);
+	for (const [collection, count] of ambiguous) warnings.push(`collection ${collection}: ${count} posts have no single address (served by more than one route, or a route parameter without a value) — no hreflang on those pages`);
+	const alternatesOf = /* @__PURE__ */ new Map();
+	for (const group of groups.values()) {
+		if (group.length < 2) continue;
+		const byLang = /* @__PURE__ */ new Map();
+		let conflict = false;
+		for (const member of group) {
+			const seen = byLang.get(member.lang);
+			if (seen !== void 0 && seen !== member.path) conflict = true;
+			byLang.set(member.lang, member.path);
+		}
+		const entry = group[0].post.entry;
+		if (conflict) {
+			warnings.push(`entry ${entry.model_id}/${entry.entry_id}: two pages claim the same language — no hreflang for this entry`);
+			continue;
+		}
+		if (byLang.size < 2) continue;
+		const alternates = [...byLang].map(([lang, path]) => ({
+			lang,
+			path
+		})).toSorted(byLangTag);
+		const fallback = byLang.get(siteLocale);
+		if (fallback !== void 0) alternates.push({
+			lang: "x-default",
+			path: fallback
+		});
+		for (const member of group) alternatesOf.set(member.post, alternates);
+	}
+	if (!alternatesOf.size) return {
+		content,
+		warnings
+	};
+	const mark = (posts) => posts.map((post) => {
+		const alternates = alternatesOf.get(post);
+		return alternates ? {
+			...post,
+			alternates
+		} : post;
+	});
+	return {
+		content: {
+			...content,
+			...content.posts ? { posts: mark(content.posts) } : {},
+			...content.collections ? { collections: Object.fromEntries(Object.entries(content.collections).map(([name, posts]) => [name, mark(posts)])) } : {}
+		},
+		warnings
+	};
+}
+//#endregion
+//#region src/noindex.ts
+/** Site-root paths (directory format, `/a/b/`) of every noindex page, sorted. */
+function noindexPaths(routes, content) {
+	const out = /* @__PURE__ */ new Set();
+	for (const route of routes) {
+		const pagePath = patternToPagePath(route.pattern);
+		if (!pagePath) continue;
+		const dynamic = pagePath.includes("[");
+		if (route.kind === "single" || route.collection !== void 0) {
+			const posts = collectionItems(content, route.collection ?? "posts");
+			if (!dynamic && posts.length !== 1) continue;
+			for (const post of posts) {
+				if (!post.noindex) continue;
+				const path = entryPath(route.pattern, {
+					...post.params,
+					slug: post.slug
+				});
+				if (path) out.add(path);
+			}
+		}
+		if (route.query) for (const page of content.queries?.[route.query] ?? []) {
+			if (!page.noindex) continue;
+			const path = entryPath(route.pattern, page.params);
+			if (path) out.add(path);
+		}
+	}
+	return [...out].toSorted();
+}
+/**
+* The `sitemap()` call for astro.config.mjs. The sitemap hands `filter` an
+* absolute, percent-encoded URL; it is compared by decoded path with the
+* trailing slash normalised, the form `noindexPaths` returns.
+*/
+function sitemapIntegration(paths) {
+	if (!paths.length) return "sitemap()";
+	return `sitemap({ filter: (page) => !NOINDEX.has(sitemapPath(page)) })`;
+}
+/** The declarations `sitemapIntegration` refers to, placed above `defineConfig`. */
+function sitemapFilterDeclarations(paths) {
+	if (!paths.length) return [];
+	return [
+		`// Pages the source site kept out of search (noindex) stay out of the sitemap.`,
+		`const NOINDEX = new Set(${JSON.stringify(paths)})`,
+		`const sitemapPath = (page) => {`,
+		`  let path = new URL(page).pathname`,
+		`  try { path = decodeURI(path) } catch { /* keep the encoded path */ }`,
+		`  return path.endsWith('/') ? path : \`\${path}/\``,
+		`}`,
+		``
+	];
+}
+//#endregion
 //#region src/scaffold.ts
-function scaffoldFiles(ir, options) {
+/**
+* `noindex` holds the site-root paths the sitemap leaves out (see noindex.ts);
+* `redirectsConfig` is the `redirects` block for astro.config.mjs (see redirects.ts);
+* `runtime` adds its host to the image allow-list (see images.ts).
+*/
+function scaffoldFiles(ir, options, noindex = [], redirectsConfig = null, runtime) {
 	const tailwind = options.tailwind !== false;
 	const split = ir.viewport_strategy === "split";
 	const sitemap = options.sitemap !== false && Boolean(ir.site.url);
+	const images = imagesEnabled(options);
+	const imageConfig = images ? astroImageConfig(imagePatterns(options, runtime)) : null;
 	const files = {};
 	files["package.json"] = stableJson({
 		name: options.projectName ?? "migrated-site",
@@ -68,7 +721,8 @@ function scaffoldFiles(ir, options) {
 				tailwindcss: "^4.0.0",
 				"@tailwindcss/vite": "^4.0.0"
 			} : {},
-			...sitemap ? { "@astrojs/sitemap": "^3.7.0" } : {}
+			...sitemap ? { "@astrojs/sitemap": "^3.7.0" } : {},
+			...images ? { sharp: "^0.34.0" } : {}
 		},
 		devDependencies: {
 			"@astrojs/check": "^0.9.0",
@@ -80,10 +734,13 @@ function scaffoldFiles(ir, options) {
 		...tailwind ? [`import tailwindcss from '@tailwindcss/vite'`] : [],
 		...sitemap ? [`import sitemap from '@astrojs/sitemap'`] : [],
 		``,
+		...sitemap ? sitemapFilterDeclarations(noindex) : [],
 		`export default defineConfig({`,
 		...ir.site.url ? [`  site: ${JSON.stringify(ir.site.url)},`] : [],
-		`  build: { format: 'directory' },`,
-		...sitemap ? [`  integrations: [sitemap()],`] : [],
+		...options.trailingSlash === false ? [`  build: { format: 'file' },`, `  trailingSlash: 'never',`] : [`  build: { format: 'directory' },`],
+		...redirectsConfig ? [redirectsConfig] : [],
+		...sitemap ? [`  integrations: [${sitemapIntegration(noindex)}],`] : [],
+		...imageConfig ? [imageConfig] : [],
 		...tailwind ? [`  vite: { plugins: [tailwindcss()] },`] : [],
 		`})`,
 		``
@@ -100,6 +757,10 @@ function scaffoldFiles(ir, options) {
 	if (tailwind) files["src/styles/modern.css"] = modernCss(ir.tokens);
 	if (options.sitemap !== false) files["public/robots.txt"] = robotsTxt(ir.site.url);
 	files["src/lib/fill.ts"] = FILL_TS;
+	if (images) {
+		files["src/lib/images.ts"] = IMAGES_TS;
+		files["src/lib/optimize-images.ts"] = optimizeImagesTs(imagePatterns(options, runtime), options.images?.widths ?? DEFAULT_IMAGE_WIDTHS, options.images?.sizes ?? "(max-width: 768px) 100vw, 768px");
+	}
 	return files;
 }
 /**
@@ -416,7 +1077,10 @@ export function validTrail(trail: unknown): Breadcrumb[] | undefined {
 export interface PageStructuredDataInput {
   url?: string
   site?: URL
+  /** The document title: the page node's name. */
   title: string
+  /** The entry's own title, when \`title\` is one an SEO plugin composed: Article headline, last crumb. */
+  headline?: string
   description?: string
   image?: string
   locale?: string
@@ -425,12 +1089,77 @@ export interface PageStructuredDataInput {
   publishedAt?: string
   modifiedAt?: string
   author?: string
+  /** The author's page (their archive), absolute: the Article author's \`url\`. */
+  authorUrl?: string
+  /** On an author's archive: who the page is about — it becomes a ProfilePage whose main entity is this Person. */
+  profile?: AuthorProfile
+  /** false: the site's addresses end without a slash — an author's page is named in that form. */
+  trailingSlash?: boolean
   siteName?: string
   /** \`@id\` of the site's own WebSite node, when its head declares one. */
   websiteId?: string
+  /** \`@id\` of the node the kept head says publishes the site (Organization or Person). */
+  publisherId?: string
+  /** What \`image\` is — an Article image with its size is an ImageObject. */
+  imageMeta?: ImageMeta
   breadcrumbs?: Breadcrumb[]
 }
 
+/**
+ * Open Graph's locale form, \`ll_RR\` (\`tr_TR\`), from a BCP 47 tag
+ * (\`tr-TR\`). A tag without a region has no OG form — guessing one would
+ * name the wrong country — so it gives undefined and the tag is left out.
+ */
+export function ogLocale(tag: string | undefined): string | undefined {
+  const match = /^([a-z]{2,3})[-_]([a-z]{2})$/i.exec(tag ?? '')
+  return match ? match[1]!.toLowerCase() + '_' + match[2]!.toUpperCase() : undefined
+}
+
+/** An author as their archive page presents them: the Person a ProfilePage is about. */
+export interface AuthorProfile {
+  name: string
+  /** The author's bio. */
+  description?: string
+  /** Avatar or photo, absolute or site-root-relative. */
+  image?: string
+  /** The author's profiles elsewhere (social accounts, a personal site) — schema.org \`sameAs\`. */
+  same_as?: string[]
+}
+
+/**
+ * An address on this site in the form its pages are named in — absolute, the
+ * page path in the site's trailing-slash form, no query or fragment — so a
+ * reference to a page and the page itself name one URL. Another host's
+ * address is kept as given.
+ */
+function siteAddress(value: string | undefined, site: URL | undefined, trailingSlash = true): string | undefined {
+  const absolute = absoluteUrl(value, site)
+  if (!absolute || !site) return absolute
+  const url = new URL(absolute)
+  if (url.host.toLowerCase() !== site.host.toLowerCase()) return absolute
+  return absoluteUrl(pagePath(url.pathname, trailingSlash), site)
+}
+
+/** An Article image: an ImageObject when its size is known, the bare URL otherwise. */
+function articleImage(url: string, meta: ImageMeta | undefined): string | Record<string, unknown> {
+  const tags = imageMetaTags(meta)
+  if (!tags.width || !tags.height) return url
+  return { '@type': 'ImageObject', url, width: Number(tags.width), height: Number(tags.height) }
+}
+
+/**
+ * Who publishes the article: the node the site's own head declares, by
+ * \`@id\`, so the logo and profile it carries count; else the site by name
+ * and address. Nothing is invented beyond the name the site gives itself.
+ */
+function publisher(input: PageStructuredDataInput): Record<string, unknown> | undefined {
+  if (input.publisherId) return { '@id': input.publisherId }
+  if (!input.siteName) return undefined
+  // The site's own address, path included: a site under /blog/ is not its host.
+  const home = input.site ? new URL(input.site.pathname.endsWith('/') ? input.site.href : input.site.href + '/').toString() : undefined
+  return { '@type': 'Organization', name: input.siteName, ...(home ? { url: home } : {}) }
+}
+
 /**
  * The page's structured data as one graph: the page itself (WebPage, or
  * CollectionPage for a list), its breadcrumb trail, and on an entry the
@@ -449,9 +1178,23 @@ export function pageStructuredData(input: PageStructuredDataInput): Record<strin
     ? trail.map((c) => ({ name: c.name, item: absoluteUrl(c.path, input.site) }))
     : []
   const breadcrumbId = url && trail && crumbs.every((c) => c.item) ? url + '#breadcrumb' : undefined
+  const authorUrl = siteAddress(input.authorUrl, input.site, input.trailingSlash)
+  // An author's archive is about a person: the page is a ProfilePage and the
+  // Person its main entity, at the page's own address — the one the author's
+  // articles name as their author's url.
+  const sameAs = (input.profile?.same_as ?? []).filter((u) => /^https?:\\/\\//i.test(u))
+  const profile = url && input.profile?.name ? {
+    '@type': 'Person',
+    '@id': url + '#person',
+    name: input.profile.name,
+    url,
+    ...(input.profile.description ? { description: input.profile.description } : {}),
+    ...(absoluteUrl(input.profile.image, input.site) ? { image: absoluteUrl(input.profile.image, input.site) } : {}),
+    ...(sameAs.length ? { sameAs } : {}),
+  } : undefined
   if (url) {
     graph.push({
-      '@type': input.pageType ?? 'WebPage',
+      '@type': profile ? 'ProfilePage' : input.pageType ?? 'WebPage',
       '@id': url,
       url,
       ...(input.title ? { name: input.title } : {}),
@@ -459,13 +1202,18 @@ export function pageStructuredData(input: PageStructuredDataInput): Record<strin
       ...(input.locale ? { inLanguage: input.locale } : {}),
       ...(input.websiteId ? { isPartOf: { '@id': input.websiteId } } : {}),
       ...(breadcrumbId ? { breadcrumb: { '@id': breadcrumbId } } : {}),
+      ...(profile ? { mainEntity: { '@id': profile['@id'] } } : {}),
+      // A page is dated as its entry is — WordPress pages have dates too.
+      ...(input.publishedAt ? { datePublished: input.publishedAt } : {}),
+      ...(input.modifiedAt ? { dateModified: input.modifiedAt } : {}),
     })
   }
+  if (profile) graph.push(profile)
   if (breadcrumbId) {
     graph.push({
       '@type': 'BreadcrumbList',
       '@id': breadcrumbId,
-      itemListElement: [...crumbs, { name: input.title, item: url }].map((c, i) => ({
+      itemListElement: [...crumbs, { name: input.headline ?? input.title, item: url }].map((c, i) => ({
         '@type': 'ListItem',
         position: i + 1,
         name: c.name,
@@ -476,19 +1224,227 @@ export function pageStructuredData(input: PageStructuredDataInput): Record<strin
   if (input.article) {
     graph.push({
       '@type': 'Article',
-      headline: input.title,
+      headline: input.headline ?? input.title,
       ...(input.description ? { description: input.description } : {}),
-      ...(input.image ? { image: [input.image] } : {}),
+      ...(input.image ? { image: [articleImage(input.image, input.imageMeta)] } : {}),
       ...(input.publishedAt ? { datePublished: input.publishedAt } : {}),
       ...(input.modifiedAt ? { dateModified: input.modifiedAt } : {}),
-      ...(input.author ? { author: { '@type': 'Person', name: input.author } } : {}),
+      // The author by the same @id their archive's ProfilePage gives its Person,
+      // so the two are one entity; name and url stay for a reader of this page alone.
+      ...(input.author ? { author: { '@type': 'Person', ...(authorUrl ? { '@id': authorUrl + '#person' } : {}), name: input.author, ...(authorUrl ? { url: authorUrl } : {}) } } : {}),
       ...(url ? { mainEntityOfPage: { '@id': url } } : {}),
-      ...(input.siteName ? { publisher: { '@type': 'Organization', name: input.siteName } } : {}),
+      ...(publisher(input) ? { publisher: publisher(input) } : {}),
     })
   }
   return graph.length ? { '@context': 'https://schema.org', '@graph': graph } : undefined
 }
 
+const SITE_SEARCH = 'SearchAction'
+
+/**
+ * An \`@id\` compared as an address: the scheme, the host's case and a slash
+ * before the fragment are not part of it, so \`https://a.com/#website\` and
+ * \`http://A.com#website\` name one node — the head and a page's graph can
+ * each have been rewritten to the new origin in their own way.
+ */
+const ldIdKey = (id: string): string => id.trim()
+  .replace(/^(?:https?:)?\\/\\/[^/?#]*/i, (origin) => origin.toLowerCase().replace(/^https?:/, ''))
+  .replace(/\\/+(?=#|$)/, '')
+
+/**
+ * The page's structured data as the source's SEO plugin rendered it, ready to
+ * print — or undefined, and the generated graph is used. What the plugin
+ * described is kept as it was (FAQ, HowTo, Product, its WebPage and Article)
+ * except a WebSite's SearchAction, which would be false on the migrated site
+ * (a static site has no ?s= search), and the nodes the kept head already
+ * carries (\`headIds\` — WebSite, Organization, its logo), which every page
+ * would otherwise print twice.
+ */
+export function sourceStructuredData(schema: unknown, headIds: string[] = []): Record<string, unknown> | undefined {
+  if (!schema || typeof schema !== 'object') return undefined
+  const root = schema as Record<string, unknown>
+  const graph = root['@graph']
+  const nodes: unknown[] = Array.isArray(schema) ? schema : Array.isArray(graph) ? graph : [schema]
+  const typesOf = (node: Record<string, unknown>): string[] =>
+    (Array.isArray(node['@type']) ? node['@type'] : [node['@type']]).filter((t): t is string => typeof t === 'string')
+  const inHead = new Set(headIds.map(ldIdKey))
+  const kept: Array<Record<string, unknown>> = []
+  for (const value of nodes) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) continue
+    let node = value as Record<string, unknown>
+    if (!typesOf(node).length) continue
+    const website = typesOf(node).some((t) => t.toLowerCase() === 'website')
+    if (typeof node['@id'] === 'string' && inHead.has(ldIdKey(node['@id']))) continue
+    if (website && node['potentialAction'] !== undefined) {
+      const action = node['potentialAction']
+      const actions = (Array.isArray(action) ? action : [action]).filter((a) =>
+        !(a && typeof a === 'object' && typesOf(a as Record<string, unknown>).includes(SITE_SEARCH)))
+      const { potentialAction: _, ...rest } = node
+      node = actions.length ? { ...rest, potentialAction: Array.isArray(action) ? actions : actions[0] } : rest
+    }
+    kept.push(node)
+  }
+  if (!kept.length) return undefined
+  const context = Array.isArray(schema) ? undefined : root['@context']
+  return { '@context': context ?? 'https://schema.org', '@graph': kept }
+}
+
+// ─── Feed and llms.txt ───
+
+/**
+ * Site-root address of an entry: its route pattern filled with the entry's
+ * parameters — the values getStaticPaths builds the page from — in the
+ * directory format the build writes. Undefined when a parameter is missing.
+ */
+export function entryAddress(pattern: string, params: Record<string, string | undefined>, trailingSlash = true): string | undefined {
+  const segments = pattern.replace(/^\\/+|\\/+$/g, '').split('/').filter(Boolean)
+  if (!segments.length) return '/'
+  const out: string[] = []
+  for (const segment of segments) {
+    if (!segment.startsWith(':')) {
+      out.push(segment)
+      continue
+    }
+    const value = params[segment.slice(1).replace(/\\*$/, '')]?.replace(/^\\/+|\\/+$/g, '')
+    if (!value) return undefined
+    out.push(value)
+  }
+  return '/' + out.join('/') + (trailingSlash ? '/' : '')
+}
+
+/**
+ * The address a built page is served at, from the path Astro gives it. The
+ * file build names a page \`/hello.html\` and the host serves it at
+ * \`/hello\`; the source site's own form — with or without the trailing
+ * slash — is what its canonical, og:url and hreflang must name.
+ */
+export function pagePath(pathname: string, trailingSlash = true): string {
+  const path = pathname.replace(/\\/index\\.html$/, '/').replace(/\\.html$/, '')
+  if (path === '/' || path === '') return '/'
+  const bare = path.replace(/\\/+$/, '')
+  return trailingSlash ? bare + '/' : bare
+}
+
+/** One page as a feed item or an llms.txt link. */
+export interface SiteLink {
+  title: string
+  url: string
+  description?: string
+  /** ISO 8601. */
+  date?: string
+  author?: string
+}
+
+/**
+ * A collection's entries as absolute links, newest first; undated entries
+ * keep their order after the dated ones. Only the entries in \`locale\` —
+ * an entry without one is in the site's default, \`siteLocale\` — and with
+ * \`indexedOnly\`, none the source kept out of search.
+ */
+export function entryLinks(posts: EmittedPost[], pattern: string, site: URL | undefined, locale: string, siteLocale: string, indexedOnly = false, trailingSlash = true): SiteLink[] {
+  const links: SiteLink[] = []
+  for (const post of posts) {
+    if ((post.locale ?? siteLocale) !== locale) continue
+    if (indexedOnly && post.noindex) continue
+    const url = absoluteUrl(entryAddress(pattern, { ...(post.params ?? {}), slug: post.slug }, trailingSlash), site)
+    if (!url) continue
+    links.push({
+      title: post.title,
+      url,
+      description: seoDescription(post.description ?? post.excerpt),
+      date: post.published_at,
+      author: post.author,
+    })
+  }
+  const time = (link: SiteLink) => (link.date ? Date.parse(link.date) || 0 : 0)
+  return links
+    .map((link, index) => ({ link, index }))
+    .sort((a, b) => time(b.link) - time(a.link) || a.index - b.index)
+    .map((entry) => entry.link)
+}
+
+/** Text for XML: escaped, and without the control characters XML 1.0 forbids. */
+const xmlText = (value: string): string => value
+  .replace(/[\\u0000-\\u0008\\u000B\\u000C\\u000E-\\u001F]/g, '')
+  .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;')
+
+export interface RssChannel {
+  title: string
+  /** The site's home page, absolute. */
+  link: string
+  /** The feed's own address, absolute. */
+  self: string
+  description?: string
+  language?: string
+  items: SiteLink[]
+}
+
+/**
+ * RSS 2.0, the format WordPress serves at /feed/. The channel's
+ * \`lastBuildDate\` is its newest item's date, so rebuilding unchanged
+ * content writes the same bytes.
+ */
+export function rssFeed(channel: RssChannel): string {
+  const rfc822 = (iso: string | undefined): string | undefined => {
+    const time = iso ? Date.parse(iso) : NaN
+    return Number.isNaN(time) ? undefined : new Date(time).toUTCString()
+  }
+  const tag = (name: string, value: string | undefined) => (value ? '<' + name + '>' + xmlText(value) + '</' + name + '>' : '')
+  const newest = channel.items.map((item) => rfc822(item.date)).find(Boolean)
+  const items = channel.items.map((item) => [
+    '<item>',
+    tag('title', item.title),
+    tag('link', item.url),
+    '<guid isPermaLink="true">' + xmlText(item.url) + '</guid>',
+    tag('pubDate', rfc822(item.date)),
+    tag('dc:creator', item.author),
+    tag('description', item.description),
+    '</item>',
+  ].filter(Boolean).join(''))
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">',
+    '<channel>',
+    tag('title', channel.title),
+    tag('link', channel.link),
+    '<atom:link href="' + xmlText(channel.self) + '" rel="self" type="application/rss+xml"/>',
+    // Required by RSS 2.0; a site without a tagline gets its title.
+    tag('description', channel.description || channel.title),
+    tag('language', channel.language),
+    tag('lastBuildDate', newest),
+    ...items,
+    '</channel>',
+    '</rss>',
+  ].filter(Boolean).join('\\n') + '\\n'
+}
+
+export interface LlmsSection {
+  name: string
+  links: SiteLink[]
+}
+
+/**
+ * /llms.txt (llmstxt.org): the site's name, its tagline, and a section of
+ * links per kind of page — what a language model reads to find its way
+ * around the site, as Yoast's generator writes it.
+ */
+export function llmsTxt(input: { title: string; description?: string; sections: LlmsSection[] }): string {
+  const line = (value: string) => value.replace(/\\s+/g, ' ').trim()
+  const label = (value: string) => line(value).replace(/[\\[\\]\\\\]/g, '\\\\$&')
+  const href = (url: string) => url.replace(/\\(/g, '%28').replace(/\\)/g, '%29').replace(/\\s/g, '%20')
+  const out = ['# ' + line(input.title)]
+  if (input.description && line(input.description)) out.push('', '> ' + line(input.description))
+  for (const section of input.sections) {
+    if (!section.links.length) continue
+    out.push('', '## ' + line(section.name), '')
+    for (const link of section.links) {
+      const description = link.description ? line(link.description) : ''
+      out.push('- [' + label(link.title) + '](' + href(link.url) + ')' + (description ? ': ' + description : ''))
+    }
+  }
+  return out.join('\\n') + '\\n'
+}
+
 /** Emitted stylesheets live under /styles/legacy/ — pages reference them by file name. */
 export const cssHref = (file: string): string => '/styles/legacy/' + (file.split('/').pop() ?? file)
 
@@ -565,8 +1521,20 @@ export interface EntryRef {
   locale?: string
 }
 
+/** Share-card values a page's source set by hand; each one left out is derived. */
+export interface SocialOverride {
+  title?: string
+  description?: string
+  image?: string
+}
+
+export interface TwitterOverride extends SocialOverride {
+  card?: string
+}
+
 export interface SeoInput {
   title?: string
+  headline?: string
   description?: string
   canonical?: string
   image?: string
@@ -578,6 +1546,13 @@ export interface SeoInput {
   publishedAt?: string
   modifiedAt?: string
   author?: string
+  authorUrl?: string
+  profile?: AuthorProfile
+  noindex?: boolean
+  nofollow?: boolean
+  openGraph?: SocialOverride
+  twitter?: TwitterOverride
+  schema?: unknown
 }
 
 /**
@@ -586,10 +1561,12 @@ export interface SeoInput {
  * only when it already reads as a path; otherwise \`image\` supplies it and
  * the tag is omitted rather than pointing at a URL that does not resolve.
  */
-export function postSeo(post: EmittedPost): SeoInput {
+export function postSeo(post: EmittedPost, kind: 'post' | 'page' = 'post'): SeoInput {
   const featured = (post.featured ?? []).find((f) => f.startsWith('/') || /^https?:/i.test(f))
   return {
-    title: post.title,
+    // The document title an SEO plugin composed; the entry's own name stays the headline.
+    title: post.seo_title || post.title,
+    headline: post.title,
     description: post.description ?? post.excerpt,
     canonical: post.canonical,
     image: post.image ?? featured,
@@ -597,10 +1574,18 @@ export function postSeo(post: EmittedPost): SeoInput {
     imageMeta: post.image ? post.image_meta : undefined,
     alternates: post.alternates,
     breadcrumbs: post.breadcrumbs,
-    type: 'article',
+    // A WordPress page is a web page, not an article: og:type website, no
+    // Article node, no article:* tags — as the source's SEO plugin printed it.
+    type: kind === 'page' ? 'website' : 'article',
     publishedAt: post.published_at,
     modifiedAt: post.modified_at,
     author: post.author,
+    authorUrl: post.author_url,
+    noindex: post.noindex,
+    nofollow: post.nofollow,
+    openGraph: post.open_graph,
+    twitter: post.twitter,
+    schema: post.schema,
   }
 }
 
@@ -617,6 +1602,14 @@ export interface EmittedPost extends MarkablePost {
   breadcrumbs?: Breadcrumb[]
   /** Canonical override; default is the page's own address. */
   canonical?: string
+  /** The author's page (their archive), absolute or site-root-relative. */
+  author_url?: string
+  /** Document title, when the source composed one apart from \`title\`. */
+  seo_title?: string
+  open_graph?: SocialOverride
+  twitter?: TwitterOverride
+  /** The source SEO plugin's JSON-LD for this page. */
+  schema?: unknown
   /** ISO 8601, for Article structured data. */
   published_at?: string
   modified_at?: string
@@ -627,6 +1620,9 @@ export interface EmittedPost extends MarkablePost {
   locale?: string
   /** Present when the producer bound this post to the content store. */
   entry?: EntryRef
+  /** Kept out of search: robots meta, and no sitemap entry. */
+  noindex?: boolean
+  nofollow?: boolean
 }
 
 /** One static path of a list route, as it appears in the emitted query data. */
@@ -643,6 +1639,13 @@ export interface EmittedQueryPage {
   image_meta?: ImageMeta
   canonical?: string
   breadcrumbs?: Breadcrumb[]
+  noindex?: boolean
+  nofollow?: boolean
+  open_graph?: SocialOverride
+  twitter?: TwitterOverride
+  schema?: unknown
+  /** On an author's archive: who the page is about. */
+  profile?: AuthorProfile
 }
 `;
 //#endregion
@@ -762,9 +1765,13 @@ function balanceWarning(html) {
 }
 //#endregion
 //#region src/seo.ts
-/** Tags the emitter owns; a source copy of any of these is replaced, not duplicated. */
+/**
+* Tags the emitter owns; a source copy of any of these is replaced, not
+* duplicated. `twitter:site` is the site's handle, the same on every page and
+* not derivable from an entry, so it stays in the head.
+*/
 const TITLE_RE = /<title\b[^>]*>[\s\S]*?<\/title>\s*/gi;
-const META_RE = /<meta\b[^>]*\b(?:name|property)\s*=\s*["'](?:description|og:[^"']*|twitter:[^"']*)["'][^>]*>\s*/gi;
+const META_RE = /<meta\b[^>]*\b(?:name|property)\s*=\s*["'](?:description|robots|googlebot|og:[^"']*|twitter:(?!site["'])[^"']*)["'][^>]*>\s*/gi;
 const CANONICAL_RE = /<link\b[^>]*\brel\s*=\s*["'][^"']*\bcanonical\b[^"']*["'][^>]*>\s*/gi;
 /**
 * A translation link names the template page's translations. An RSS
@@ -913,7 +1920,55 @@ function decideLd(json) {
 * — the node the page's WebPage says it is part of. Only what the head says:
 * no id, no link.
 */
-function websiteIdOf(html) {
+function websiteIdOf(html) {
+	for (const match of html.matchAll(JSONLD_RE)) {
+		let parsed;
+		try {
+			parsed = JSON.parse(match[1] ?? "");
+		} catch {
+			continue;
+		}
+		const graph = parsed?.["@graph"];
+		const nodes = Array.isArray(parsed) ? parsed : Array.isArray(graph) ? graph : [parsed];
+		for (const node of nodes) {
+			const id = node?.["@id"];
+			if (typeof id === "string" && id && typesOf(node).some((t) => t.toLowerCase() === "website")) return id;
+		}
+	}
+}
+/**
+* \`@id\` of every node in a head's structured data — the site's own nodes
+* (WebSite, Organization, its logo) that every page already carries. A page's
+* plugin graph repeats them; printing them twice is valid but is noise.
+*/
+function headLdIdsOf(html) {
+	const ids = [];
+	for (const match of html.matchAll(JSONLD_RE)) {
+		let parsed;
+		try {
+			parsed = JSON.parse(match[1] ?? "");
+		} catch {
+			continue;
+		}
+		const graph = parsed?.["@graph"];
+		const nodes = Array.isArray(parsed) ? parsed : Array.isArray(graph) ? graph : [parsed];
+		for (const node of nodes) {
+			const id = node?.["@id"];
+			if (typeof id === "string" && id && !ids.includes(id)) ids.push(id);
+		}
+	}
+	return ids;
+}
+/**
+* `@id` of the node that publishes the site, as the head's structured data
+* says: the WebSite's own `publisher` reference (Yoast and Rank Math write
+* one — an Organization, or the Person a personal site is published by),
+* else the head's first Organization. The Article names it by `@id`, so the
+* logo and profile the site declared count for every post.
+*/
+function publisherIdOf(html) {
+	const declared = new Set(headLdIdsOf(html));
+	let organization;
 	for (const match of html.matchAll(JSONLD_RE)) {
 		let parsed;
 		try {
@@ -924,15 +1979,39 @@ function websiteIdOf(html) {
 		const graph = parsed?.["@graph"];
 		const nodes = Array.isArray(parsed) ? parsed : Array.isArray(graph) ? graph : [parsed];
 		for (const node of nodes) {
+			const types = typesOf(node).map((t) => t.toLowerCase());
+			if (types.includes("website")) {
+				const ref = node["publisher"];
+				const id = Array.isArray(ref) ? ref[0] : ref;
+				if (typeof id?.["@id"] === "string" && declared.has(id["@id"])) return id["@id"];
+			}
 			const id = node?.["@id"];
-			if (typeof id === "string" && id && typesOf(node).some((t) => t.toLowerCase() === "website")) return id;
+			if (!organization && typeof id === "string" && id && isSiteNode(node) && !types.includes("website")) organization = id;
 		}
 	}
+	return organization;
+}
+/** Directives that say whether THIS page is indexed or followed; everything else is a site setting. */
+const PAGE_ROBOTS = new Set([
+	"index",
+	"noindex",
+	"follow",
+	"nofollow",
+	"all",
+	"none"
+]);
+function siteRobots(tag, into) {
+	const content = /\bcontent\s*=\s*(?:"([^"]*)"|'([^']*)')/i.exec(tag);
+	for (const raw of (content?.[1] ?? content?.[2] ?? "").split(",")) {
+		const directive = raw.trim().toLowerCase();
+		if (directive && !PAGE_ROBOTS.has(directive) && !into.includes(directive)) into.push(directive);
+	}
 }
 /** Remove the source head's per-page SEO tags so the emitter's own are the only ones. */
 function stripSeoTags(html) {
 	const removed = [];
 	const kept = [];
+	const robots = [];
 	const note = (label) => {
 		if (!removed.includes(label)) removed.push(label);
 	};
@@ -942,6 +2021,7 @@ function stripSeoTags(html) {
 	});
 	out = out.replace(META_RE, (tag) => {
 		const name = /\b(?:name|property)\s*=\s*["']([^"']+)["']/i.exec(tag)?.[1] ?? "meta";
+		if (/^(?:robots|googlebot)$/i.test(name)) siteRobots(tag, robots);
 		note(name.toLowerCase().startsWith("og:") ? "og:*" : name.toLowerCase().startsWith("twitter:") ? "twitter:*" : name);
 		return "";
 	});
@@ -965,7 +2045,8 @@ function stripSeoTags(html) {
 	return {
 		html: out,
 		removed,
-		kept
+		kept,
+		robots
 	};
 }
 /**
@@ -1001,10 +2082,13 @@ const SEO_COMPONENT = `---
  * Canonical and absolute URLs need \`site\` in astro.config.mjs; without it the
  * canonical link and og:url are omitted rather than pointing at a build host.
  */
-import { absoluteUrl, imageMetaTags, jsonLd, pageStructuredData, seoDescription, type Breadcrumb, type ImageMeta } from '../lib/fill'
+import { absoluteUrl, imageMetaTags, jsonLd, ogLocale, pagePath, pageStructuredData, seoDescription, sourceStructuredData, type AuthorProfile, type Breadcrumb, type ImageMeta, type SocialOverride, type TwitterOverride } from '../lib/fill'
 
 interface Props {
+  /** The document title — an SEO plugin's composed one when the source had it. */
   title?: string
+  /** The entry's own title, when it differs from \`title\`: Article headline, last breadcrumb. */
+  headline?: string
   /** Meta description; falls back to the entry's excerpt, tags stripped. */
   description?: string
   /** Overrides the generated address — for a page that canonicalises elsewhere. */
@@ -1021,18 +2105,42 @@ interface Props {
   pageType?: 'WebPage' | 'CollectionPage'
   /** \`@id\` of the site's WebSite node kept in the head chrome, when there is one. */
   websiteId?: string
+  /** \`@id\` of the node the kept head says publishes the site — the Article's publisher. */
+  publisherId?: string
+  /** false: the site's addresses end without a slash (\`/hello\`), as the source's did. */
+  trailingSlash?: boolean
+  /** \`@id\` of every structured-data node the head chrome keeps — not repeated from \`schema\`. */
+  headLdIds?: string[]
   /** \`article\` on entry pages, \`website\` on lists and static pages. */
   type?: 'article' | 'website'
   /** ISO 8601 — structured data only; the displayed date stays a mark. */
   publishedAt?: string
   modifiedAt?: string
   author?: string
+  /** The author's page, for the Article author's \`url\`. */
+  authorUrl?: string
+  /** On an author's archive: who the page is about — ProfilePage + Person. */
+  profile?: AuthorProfile
+  /** This page's own feed (an archive's), site-root-relative: \`<link rel="alternate" type="application/rss+xml">\`. */
+  feed?: { path: string; title?: string }
   siteName?: string
   locale?: string
+  /** The page is kept out of search: \`<meta name="robots" content="noindex">\`. */
+  noindex?: boolean
+  nofollow?: boolean
+  /** Site-wide robots directives from the template head (\`max-image-preview:large\`, …), printed on every page. */
+  robotsDefault?: string[]
+  /** Share-card values the source set by hand, over the derived ones. */
+  openGraph?: SocialOverride
+  /** Unset values follow Open Graph. */
+  twitter?: TwitterOverride
+  /** The source SEO plugin's JSON-LD for this page — printed instead of the generated graph. */
+  schema?: unknown
 }
 
 const {
   title = '',
+  headline,
   description,
   canonical,
   image,
@@ -1041,68 +2149,305 @@ const {
   breadcrumbs,
   pageType,
   websiteId,
+  publisherId,
+  trailingSlash = true,
+  headLdIds = [],
   type = 'website',
   publishedAt,
   modifiedAt,
   author,
+  authorUrl,
+  profile,
+  feed,
   siteName,
   locale,
+  noindex = false,
+  nofollow = false,
+  robotsDefault = [],
+  openGraph,
+  twitter,
+  schema,
 } = Astro.props
 
 const site = Astro.site
-const url = canonical ? absoluteUrl(canonical, site) : absoluteUrl(Astro.url.pathname, site)
+const url = canonical ? absoluteUrl(canonical, site) : absoluteUrl(pagePath(Astro.url.pathname, trailingSlash), site)
 const imageUrl = absoluteUrl(image, site)
 const imageTags = imageUrl ? imageMetaTags(imageMeta) : {}
 // hreflang needs absolute URLs; without \`site\` there are none to give.
 const hreflang = alternates.flatMap((a) => {
-  const href = absoluteUrl(a.path, site)
+  const href = absoluteUrl(pagePath(a.path, trailingSlash), site)
   return href ? [{ lang: a.lang, href }] : []
 })
-const localeAlternates = [...new Set(hreflang.map((a) => a.lang))].filter((l) => l !== 'x-default' && l !== locale)
+// og:locale takes ll_RR; a language without a region has no such form and is left out.
+const ogLang = ogLocale(locale)
+const localeAlternates = [...new Set(hreflang.map((a) => ogLocale(a.lang)))].filter((l): l is string => Boolean(l) && l !== ogLang)
 const desc = seoDescription(description)
+const robots = [noindex && 'noindex', nofollow && 'nofollow', ...robotsDefault].filter(Boolean).join(', ')
+// Share cards: what the source set by hand, else what the page says.
+const ogTitle = openGraph?.title || title
+const ogDesc = seoDescription(openGraph?.description) ?? desc
+const ogImage = absoluteUrl(openGraph?.image, site) ?? imageUrl
+// The measurements describe \`image\`; an override is another file.
+const ogImageTags = ogImage === imageUrl ? imageTags : {}
+const twTitle = twitter?.title || ogTitle
+const twDesc = seoDescription(twitter?.description) ?? ogDesc
+const twImage = absoluteUrl(twitter?.image, site) ?? ogImage
+const twCard = twitter?.card === 'summary' || twitter?.card === 'summary_large_image' ? twitter.card : twImage ? 'summary_large_image' : 'summary'
 const article = type === 'article'
-const structured = pageStructuredData({
+const structured = sourceStructuredData(schema, headLdIds) ?? pageStructuredData({
   url,
   site,
   title,
+  headline,
   description: desc,
   image: imageUrl,
+  imageMeta: imageUrl ? imageMeta : undefined,
   locale,
   article,
   pageType,
   publishedAt,
   modifiedAt,
   author,
+  authorUrl,
+  profile,
+  trailingSlash,
   siteName,
   websiteId,
+  publisherId,
   breadcrumbs,
 })
 ---
 <title>{title}</title>
+{robots && <meta name="robots" content={robots} />}
 {desc && <meta name="description" content={desc} />}
 {url && <link rel="canonical" href={url} />}
 {hreflang.map((a) => <link rel="alternate" hreflang={a.lang} href={a.href} />)}
+{feed && <link rel="alternate" type="application/rss+xml" title={feed.title} href={feed.path} />}
 <meta property="og:type" content={type} />
-{title && <meta property="og:title" content={title} />}
-{desc && <meta property="og:description" content={desc} />}
+{ogTitle && <meta property="og:title" content={ogTitle} />}
+{ogDesc && <meta property="og:description" content={ogDesc} />}
 {url && <meta property="og:url" content={url} />}
-{imageUrl && <meta property="og:image" content={imageUrl} />}
-{imageTags.width && <meta property="og:image:width" content={imageTags.width} />}
-{imageTags.height && <meta property="og:image:height" content={imageTags.height} />}
-{imageTags.type && <meta property="og:image:type" content={imageTags.type} />}
+{ogImage && <meta property="og:image" content={ogImage} />}
+{ogImageTags.width && <meta property="og:image:width" content={ogImageTags.width} />}
+{ogImageTags.height && <meta property="og:image:height" content={ogImageTags.height} />}
+{ogImageTags.type && <meta property="og:image:type" content={ogImageTags.type} />}
 {siteName && <meta property="og:site_name" content={siteName} />}
-{locale && <meta property="og:locale" content={locale} />}
+{ogLang && <meta property="og:locale" content={ogLang} />}
 {localeAlternates.map((l) => <meta property="og:locale:alternate" content={l} />)}
 {article && publishedAt && <meta property="article:published_time" content={publishedAt} />}
 {article && modifiedAt && <meta property="article:modified_time" content={modifiedAt} />}
 {article && author && <meta property="article:author" content={author} />}
-<meta name="twitter:card" content={imageUrl ? 'summary_large_image' : 'summary'} />
-{title && <meta name="twitter:title" content={title} />}
-{desc && <meta name="twitter:description" content={desc} />}
-{imageUrl && <meta name="twitter:image" content={imageUrl} />}
+<meta name="twitter:card" content={twCard} />
+{twTitle && <meta name="twitter:title" content={twTitle} />}
+{twDesc && <meta name="twitter:description" content={twDesc} />}
+{twImage && <meta name="twitter:image" content={twImage} />}
 {structured && <script is:inline type="application/ld+json" set:html={jsonLd(structured)} />}
 `;
 //#endregion
+//#region src/feed.ts
+/** Where the feed is built. */
+const FEED_PATH = "/feed.xml";
+/** WordPress's feed address, redirected (301) to FEED_PATH. */
+const FEED_REDIRECT_FROM = "/feed/";
+/** Items in the feed — WordPress's default `posts_per_rss`. */
+const FEED_ITEMS = 10;
+/** Links per llms.txt section. A long archive is summarised by its newest pages. */
+const LLMS_LINKS = 100;
+/**
+* The collections the site builds entry pages for in its default language,
+* each with the first route that does: posts first, pages next, the rest by
+* name. A route in another language is left out — the feed and llms.txt
+* describe the site as it is in its default one.
+*/
+function linkSources(routes, siteLocale) {
+	const byCollection = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		if (route.kind !== "single" && route.collection === void 0) continue;
+		if ((route.locale ?? siteLocale) !== siteLocale) continue;
+		const pagePath = patternToPagePath(route.pattern);
+		if (!pagePath || !pagePath.includes("[")) continue;
+		const collection = route.collection ?? "posts";
+		if (!byCollection.has(collection)) byCollection.set(collection, route.pattern);
+	}
+	const rank = (c) => c === "posts" ? 0 : c === "pages" ? 1 : 2;
+	return [...byCollection].map(([collection, pattern]) => ({
+		collection,
+		pattern
+	})).toSorted((a, b) => rank(a.collection) - rank(b.collection) || (a.collection < b.collection ? -1 : a.collection > b.collection ? 1 : 0));
+}
+/**
+* Archive routes in the site's default language whose every page is an
+* address with a feed: a query route with parameters and no page number —
+* `/category/:term*`, `/tag/:term`, `/author/:author`. The paginated
+* continuation (`/category/:term/page/:page`) has no feed of its own.
+*/
+function archiveFeedSources(routes, siteLocale) {
+	const out = [];
+	for (const route of routes) {
+		if (!route.query || (route.locale ?? siteLocale) !== siteLocale) continue;
+		const pagePath = patternToPagePath(route.pattern);
+		if (!pagePath || !pagePath.includes("[")) continue;
+		if (route.pattern.split("/").some((seg) => /^:page\*?$/.test(seg))) continue;
+		out.push({
+			routeId: route.id,
+			pattern: route.pattern,
+			query: route.query
+		});
+	}
+	return out;
+}
+/** Where an archive route's feed endpoint lives: its page path with `/feed.xml` appended. */
+function archiveFeedFile(pattern) {
+	const pagePath = patternToPagePath(pattern);
+	return pagePath ? `src/pages/${pagePath.replace(/\.astro$/, "")}/feed.xml.ts` : null;
+}
+/**
+* The feed of every page an archive route builds — the newest posts it lists,
+* at their own addresses — at `<archive>/feed.xml`. Its entries are the
+* route's own first result set, so the feed lists what the archive page does.
+*/
+function archiveFeedEndpoint(source, postPattern, input) {
+	const locale = JSON.stringify(input.siteLocale);
+	const file = archiveFeedFile(source.pattern);
+	const up = "../".repeat(file.split("/").length - 2);
+	const slash = input.trailingSlash === false ? ", false, false" : "";
+	return `// Archive feed for route ${source.routeId} (${source.pattern}) — emitted by @contentrain/emitter-astro.
+// One feed per page the archive builds, at <archive>/feed.xml, as WordPress serves
+// one at <archive>/feed/: the 10 newest posts the archive lists.
+import type { APIRoute, GetStaticPaths } from 'astro'
+import data from '${up}data/queries/${source.query}.json'
+import { absoluteUrl, entryAddress, entryLinks, rssFeed, type EmittedQueryPage } from '${up}lib/fill'
+
+export const getStaticPaths = (() => (data as EmittedQueryPage[]).map((page) => ({ params: page.params, props: { page } }))) satisfies GetStaticPaths
+
+export const GET: APIRoute = ({ props, site }) => {
+  const page = (props as { page: EmittedQueryPage }).page
+  const address = entryAddress(${JSON.stringify(source.pattern)}, page.params) ?? '/'
+  const items = entryLinks(page.items, ${JSON.stringify(postPattern)}, site, ${locale}, ${locale}${slash}).slice(0, 10)
+  const body = rssFeed({
+    title: page.title || ${JSON.stringify(siteTitle(input.ir))},
+    link: absoluteUrl(address, site) ?? '',
+    self: absoluteUrl(address + 'feed.xml', site) ?? '',
+    description: page.description ?? ${JSON.stringify(input.description ?? "")},
+    language: ${locale},
+    items,
+  })
+  return new Response(body, { headers: { 'Content-Type': 'application/rss+xml; charset=utf-8' } })
+}
+`;
+}
+const sectionName = (collection) => collection.charAt(0).toUpperCase() + collection.slice(1).replace(/[-_]+/g, " ");
+function siteTitle(ir) {
+	if (ir.site.title?.trim()) return ir.site.title.trim();
+	try {
+		return new URL(ir.site.url).host;
+	} catch {
+		return ir.site.url;
+	}
+}
+/** `src/pages/feed.xml.ts`: the newest posts as RSS 2.0. */
+function feedEndpoint(source, input) {
+	const locale = JSON.stringify(input.siteLocale);
+	return `// RSS feed at ${FEED_PATH} — emitted by @contentrain/emitter-astro.
+// Built from the data the post pages are built from: the 10 newest posts,
+// each at the address its own page has.
+import type { APIRoute } from 'astro'
+import data from '../data/${source.collection}.json'
+import { entryLinks, rssFeed, type EmittedPost } from '../lib/fill'
+
+export const GET: APIRoute = ({ site }) => {
+  const items = entryLinks(data as EmittedPost[], ${JSON.stringify(source.pattern)}, site, ${locale}, ${locale}${input.trailingSlash === false ? ", false, false" : ""}).slice(0, 10)
+  const body = rssFeed({
+    title: ${JSON.stringify(siteTitle(input.ir))},
+    link: new URL('/', site).toString(),
+    self: new URL(${JSON.stringify(FEED_PATH)}, site).toString(),
+    description: ${JSON.stringify(input.description ?? "")},
+    language: ${locale},
+    items,
+  })
+  return new Response(body, { headers: { 'Content-Type': 'application/rss+xml; charset=utf-8' } })
+}
+`;
+}
+/** `src/pages/llms.txt.ts`: a section of links per collection. */
+function llmsEndpoint(sources, input) {
+	const locale = JSON.stringify(input.siteLocale);
+	const imports = sources.map((s, i) => `import c${i} from '../data/${s.collection}.json'`);
+	const sections = sources.map((s, i) => `    { name: ${JSON.stringify(sectionName(s.collection))}, links: entryLinks(c${i} as EmittedPost[], ${JSON.stringify(s.pattern)}, site, ${locale}, ${locale}, true${input.trailingSlash === false ? ", false" : ""}).slice(0, 100) },`);
+	return `// /llms.txt (llmstxt.org) — emitted by @contentrain/emitter-astro.
+// What a language model reads to find its way around the site: its name, its
+// tagline, and the newest 100 pages of each kind, at their own addresses —
+// none the source kept out of search (noindex).
+import type { APIRoute } from 'astro'
+${imports.join("\n")}
+import { entryLinks, llmsTxt, type EmittedPost } from '../lib/fill'
+
+export const GET: APIRoute = ({ site }) => {
+  const body = llmsTxt({
+    title: ${JSON.stringify(siteTitle(input.ir))},
+    description: ${JSON.stringify(input.description ?? "")},
+    sections: [
+${sections.join("\n")}
+    ],
+  })
+  return new Response(body, { headers: { 'Content-Type': 'text/plain; charset=utf-8' } })
+}
+`;
+}
+const FEED_LINK_RE = /<link\b(?=[^>]*\brel\s*=\s*["']?[^"'>]*\balternate\b)(?=[^>]*\btype\s*=\s*["']?application\/(?:rss|atom)\+xml)[^>]*>/gi;
+const HREF_RE = /(\bhref\s*=\s*)(["'])([^"']*)\2/i;
+/** www. and the bare host are one site: a WordPress head often names the other. */
+const siteHost = (url) => url.host.toLowerCase().replace(/^www\./, "");
+/**
+* The feed a head link names, when it is one of the site's own: `main` for
+* WordPress's main RSS feed (/feed/, /feed/rss2/, ?feed=rss2), `other` for
+* the rest it serves (comments, a category, Atom). A feed on another host —
+* FeedBurner, a newsletter tool — is not the site's to build or to break.
+*/
+function ownFeed(href, type, site) {
+	let url;
+	try {
+		url = new URL(href, site);
+	} catch {
+		return;
+	}
+	if (siteHost(url) !== siteHost(site)) return void 0;
+	const path = url.pathname.replace(/\/+$/, "");
+	const query = url.searchParams.get("feed");
+	return (path === "/feed" || path === "/feed/rss2" || path === "/feed/rss" || path === "" && (query === "rss2" || query === "rss")) && /rss\+xml/i.test(type) ? "main" : "other";
+}
+/** Point the head's link to the site's main feed at the one the build writes, and remove the template page's others. */
+function rewriteFeedLinks(html, siteUrl) {
+	let site;
+	try {
+		site = new URL(siteUrl);
+	} catch {
+		return {
+			html,
+			rewritten: 0,
+			other: 0
+		};
+	}
+	let rewritten = 0;
+	let other = 0;
+	return {
+		html: html.replace(FEED_LINK_RE, (tag) => {
+			const href = HREF_RE.exec(tag);
+			const type = /\btype\s*=\s*["']?([^"'\s>]+)/i.exec(tag)?.[1] ?? "";
+			const kind = href ? ownFeed(href[3] ?? "", type, site) : void 0;
+			if (kind === "other") {
+				other++;
+				return "";
+			}
+			if (kind !== "main") return tag;
+			rewritten++;
+			return tag.replace(HREF_RE, `$1$2${FEED_PATH}$2`);
+		}),
+		rewritten,
+		other
+	};
+}
+//#endregion
 //#region src/layouts.ts
 /** A component the family's chrome mounts at a `<!--@@component:ID@@-->` marker. */
 /** A safe identifier for a query id used as a module-local variable name. */
@@ -1170,14 +2515,21 @@ function familyFiles(family, lang, components = [], definitions = /* @__PURE__ *
 	}
 	for (const placement of family.components ?? []) if (!mounts.some((m) => m.id === placement.component)) warnings.push(`family ${family.id}: component placement "${placement.component}" has no marker in the body chrome or in any content body — not mounted`);
 	let head = joined("head");
+	let robotsDefault = [];
 	if (seoOn) {
 		const stripped = stripSeoTags(head);
 		head = stripped.html;
+		robotsDefault = stripped.robots;
 		if (stripped.removed.length) {
 			const kept = stripped.kept.length ? `; kept the site-wide ${stripped.kept.join(", ")} from its structured data` : "";
 			warnings.push(`family ${family.id}: removed the template page's ${stripped.removed.join(", ")} from head chrome — these describe one page, and the emitter renders title, description, canonical, social tags and Article data per page${kept}`);
 		}
 	}
+	if (options.feedSite) {
+		const feed = rewriteFeedLinks(head, options.feedSite);
+		head = feed.html;
+		if (feed.other) warnings.push(`family ${family.id}: removed ${feed.other} feed links from the head chrome — the template page's own archive feed, or a comments or Atom feed the site does not build; each archive page links its own feed`);
+	}
 	const files = {};
 	files[`src/data/chrome/${family.id}.json`] = stableJson({
 		head,
@@ -1187,8 +2539,14 @@ function familyFiles(family, lang, components = [], definitions = /* @__PURE__ *
 	});
 	const cssLinks = (family.css.files ?? []).map((f) => `<link rel="stylesheet" href="/styles/legacy/${f.split("/").pop()}" />`).join("\n");
 	const siteNameProp = options.siteName ? ` siteName={${JSON.stringify(options.siteName)}}` : "";
+	const trailingSlashProp = options.trailingSlash === false ? " trailingSlash={false}" : "";
+	const publisherId = seoOn ? publisherIdOf(head) : void 0;
+	const publisherIdProp = publisherId ? ` publisherId={${JSON.stringify(publisherId)}}` : "";
 	const websiteId = seoOn ? websiteIdOf(head) : void 0;
 	const websiteIdProp = websiteId ? ` websiteId={${JSON.stringify(websiteId)}}` : "";
+	const robotsProp = robotsDefault.length ? ` robotsDefault={${JSON.stringify(robotsDefault)}}` : "";
+	const headLdIds = seoOn ? headLdIdsOf(head) : [];
+	const headLdIdsProp = headLdIds.length ? ` headLdIds={${JSON.stringify(headLdIds)}}` : "";
 	const imported = [...new Set([...components.map((c) => c.name), ...mounts.map((m) => m.name)])];
 	const componentImports = [...seoOn ? [`import Seo from '../components/Seo.astro'`] : [], ...imported.map((n) => `import ${n} from '../components/${n}.astro'`)].join("\n");
 	const mountType = [...new Set(mounts.map((m) => `typeof ${m.name}`))].join(" | ");
@@ -1214,7 +2572,7 @@ const parts = splitComponents(html).map((part) => ({
 // Family: ${family.id}${family.name ? ` (${family.name})` : ""} — emitted by @contentrain/emitter-astro
 import chrome from '../data/chrome/${family.id}.json'
 import { cssHref, fillAttrs, renderTemplate, composeBody${mounts.length ? ", splitComponents" : ""}${queryMounts.length ? ", renderQuery, type EmittedQueryPage" : ""}${seoOn ? ", type SeoInput" : ""} } from '../lib/fill'
-${queryImports}${queryImports ? "\n" : ""}
+${options.images ? `import { optimizeHtmlImages } from '../lib/optimize-images'\n` : ""}${queryImports}${queryImports ? "\n" : ""}
 ${componentImports ? `${componentImports}\n` : ""}
 interface Props {
   title?: string
@@ -1227,218 +2585,43 @@ interface Props {
   lang?: string
   /** Content-store address of the page's entry — mounted components (comments) key on it. */
   entry?: { model_id: string; entry_id: string; locale?: string }${seoOn ? `
-  /** Per-page SEO — see src/components/Seo.astro. */
-  seo?: SeoInput` : ""}
-}
-const { title = '', marks = {}, body, css = [], lang = ${JSON.stringify(lang)}${mounts.length ? ", entry" : ""}${seoOn ? ", seo" : ""} } = Astro.props
-const head = renderTemplate(chrome.head, marks)
-// Root attributes carry the theme's layout hooks; values may hold @@marks@@.
-// An explicit lang from the source wins over the project default.
-const htmlAttrs = { lang, ...fillAttrs(chrome.html_attrs, marks) }
-const bodyAttrs = fillAttrs(chrome.body_attrs, marks)
-const content = body ?? (Astro.slots.has('default') ? await Astro.slots.render('default') : '')
-// Split at the marker FIRST, then fill marks per side — filling first would
-// eat the @@body@@ inside the marker and silently drop the content.
-const html = composeBody(chrome.body, marks, content)
-${queryRender}${mountTable}---
-<!doctype html>
-<html {...htmlAttrs}>
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width,initial-scale=1" />
-${cssLinks.split("\n").filter(Boolean).map((l) => `    ${l}`).join("\n")}
-    {css.map((file) => (
-      <link rel="stylesheet" href={cssHref(file)} />
-    ))}
-    <Fragment set:html={head} />
-${seoOn ? `    <Seo title={title} locale={lang}${siteNameProp}${websiteIdProp} {...(seo ?? {})} />` : `    <title>{title}</title>`}
-  </head>
-  <body {...bodyAttrs}>
-${renderRefs("header") ? `${renderRefs("header")}\n` : ""}${bodyRender}
-${renderRefs("footer") ? `${renderRefs("footer")}\n` : ""}  </body>
-</html>
-`;
-	return {
-		files,
-		warnings
-	};
-}
-//#endregion
-//#region src/pages.ts
-function routeFiles(route, family, content, siteLocale, seo = true) {
-	const warnings = [];
-	const files = {};
-	const pagePath = patternToPagePath(route.pattern);
-	if (!pagePath) return {
-		files,
-		warnings: [`route ${route.id}: pattern "${route.pattern}" cannot be expressed as an Astro page — skipped`]
-	};
-	if (!family) return {
-		files,
-		warnings: [`route ${route.id}: family "${route.family}" not found — skipped`]
-	};
-	const layout = pascalCase(family.id);
-	const depth = pagePath.split("/").length - 1;
-	const up = "../".repeat(depth + 1) || "../";
-	const hasParams = pagePath.includes("[");
-	const restAt = restParamIndex(pagePath);
-	if (restAt !== -1 && restAt !== pagePath.split("/").length - 1) warnings.push(`route ${route.id}: rest parameter is not the final segment of "${route.pattern}" — Astro matches rest parameters greedily; verify this route resolves`);
-	if (route.kind === "single" || route.collection !== void 0) {
-		const collection = route.collection ?? "posts";
-		const posts = collectionItems(content, collection);
-		if (!posts.length) warnings.push(`route ${route.id}: collection "${collection}" has no items — page emitted, data file empty`);
-		files[`src/data/${collection}.json`] = stableJson(posts);
-		files[`src/pages/${pagePath}`] = singlePage(route, layout, up, collection, siteLocale, hasParams, seo);
-		return {
-			files,
-			warnings
-		};
-	}
-	const queryPages = route.query ? content.queries?.[route.query] ?? [] : [];
-	if (route.query) {
-		if (!queryPages.length) warnings.push(`route ${route.id}: query "${route.query}" has no data — page emitted, data file empty`);
-		if (queryPages.some((p) => !p.item_template && !p.sections?.length)) warnings.push(`route ${route.id}: item template missing on some pages — plain fallback list rendered (not fidelity)`);
-		files[`src/data/queries/${route.query}.json`] = stableJson(queryPages);
-		files[`src/pages/${pagePath}`] = listPage(route, layout, up, hasParams, siteLocale, seo);
-		return {
-			files,
-			warnings
-		};
-	}
-	files[`src/pages/${pagePath}`] = staticPage(route, layout, up, hasParams, warnings, siteLocale, seo);
-	return {
-		files,
-		warnings
-	};
-}
-/** Items of a named collection; `posts` also accepts the `content.posts` shorthand. */
-function collectionItems(content, collection) {
-	const named = content.collections?.[collection];
-	if (named) return named;
-	return collection === "posts" ? content.posts ?? [] : [];
-}
-function singlePage(route, layout, up, collection, siteLocale, hasParams, seo) {
-	const locale = JSON.stringify(route.locale ?? siteLocale);
-	return `---
-// Route: ${route.id} (${route.pattern}) — collection: ${collection} — emitted by @contentrain/emitter-astro
-import Layout from '${up}layouts/${layout}.astro'
-import data from '${up}data/${collection}.json'
-import { postMarks${seo ? ", postSeo" : ""}, type EmittedPost } from '${up}lib/fill'
-
-${hasParams ? `export function getStaticPaths() {
-  // The JSON is data; its contract is EmittedPost. Inferring the type from the
-  // file would type only the fields this site happens to carry, and "astro
-  // check" (which the build runs first) would then reject post.params on a site
-  // whose permalinks need none. The cast lives INSIDE getStaticPaths because
-  // Astro hoists this function: it sees imports, not the component scope.
-  const posts = data as EmittedPost[]
-  // A post carries its own route parameters (date parts of a dated permalink,
-  // a post id) — using the template post's would send every other post to the
-  // wrong address.
-  return posts.map((post) => ({ params: { ...(post.params ?? {}), slug: post.slug }, props: { post } }))
-}
-type Props = { post: EmittedPost }
-const { post } = Astro.props as Props` : `const posts = data as EmittedPost[]
-if (posts.length !== 1) throw new Error(${JSON.stringify(`Static content route requires exactly one entry: ${route.id}`)})
-const post = posts[0]!`}
----
-<Layout
-  title={post.title}
-  marks={postMarks(post)}
-  body={post.body}
-  css={post.css ?? []}
-  lang={post.locale ?? ${locale}}
-  entry={post.entry}${seo ? `
-  seo={postSeo(post)}` : ""}
-/>
-`;
-}
-function listPage(route, layout, up, hasParams, siteLocale, seo) {
-	const locale = JSON.stringify(route.locale ?? siteLocale);
-	const routeTitle = route.title === void 0 ? `''` : JSON.stringify(route.title);
-	const paths = hasParams ? `export function getStaticPaths() {
-  const pages = data as EmittedQueryPage[]
-  return pages.map((page) => ({ params: page.params, props: { page } }))
-}
-type Props = { page: EmittedQueryPage }
-const { page } = Astro.props as Props` : `const page = (data as EmittedQueryPage[])[0] ?? { params: {}, items: [], title: undefined }`;
-	return `---
-// Route: ${route.id} (${route.pattern}) — emitted by @contentrain/emitter-astro
-import Layout from '${up}layouts/${layout}.astro'
-import data from '${up}data/queries/${route.query}.json'
-import { renderQueryPage, type EmittedQueryPage } from '${up}lib/fill'
-
-${paths}
-// A list renders in sections (a big card then a grid) — one template is the
-// single-section case. Without a template at all it falls back to a plain list
-// and the emitter has already warned: silence would read as fidelity.
-const content = renderQueryPage(page)
-// Route params carry slugs; page marks carry what the chrome needs to SHOW
-// (a term's display name, description, count).
-const marks = { ...page.params, ...(page.marks ?? {}) }
-const title = page.title ?? ${routeTitle}
----
-<Layout
-  title={title || String(marks.term_name ?? page.params.term ?? '')}
-  marks={marks}
-  body={content}
-  css={page.css ?? []}
-  lang={${locale}}${seo ? `
-  seo={{ description: page.description, image: page.image, imageMeta: page.image_meta, canonical: page.canonical, breadcrumbs: page.breadcrumbs, type: 'website', pageType: 'CollectionPage' }}` : ""}
-/>
-`;
-}
-function staticPage(route, layout, up, hasParams, warnings, siteLocale, seo) {
-	if (hasParams) warnings.push(`route ${route.id}: parameterized route without a query — emitted with empty paths`);
-	const paths = hasParams ? `export function getStaticPaths() {
-  return []
-}
-` : "";
-	return `---
-// Route: ${route.id} (${route.pattern}) — emitted by @contentrain/emitter-astro
-import Layout from '${up}layouts/${layout}.astro'
-${paths}---
-<Layout title=${JSON.stringify(route.title ?? "")} marks={{}} lang={${JSON.stringify(route.locale ?? siteLocale)}}${seo ? ` seo={{ type: 'website' }}` : ""} />
-`;
-}
-/** Share a catchall while preserving the original editable collections. */
-function sharedCollectionPage(routes, content, siteLocale, seo = true) {
-	const pattern = routes[0]?.pattern;
-	if (!pattern || routes.length < 2 || !/^\/(?:[^:*]+\/)*:slug\*$/.test(pattern) || routes.some((r) => r.pattern !== pattern || r.query || r.kind !== "single" && !r.collection)) return void 0;
-	const seen = /* @__PURE__ */ new Set();
-	for (const route of routes) for (const post of collectionItems(content, route.collection ?? "posts")) {
-		let key;
-		try {
-			key = decodeURIComponent(post.slug).replace(/\/+$/, "");
-		} catch {
-			return;
-		}
-		if (seen.has(key)) return void 0;
-		seen.add(key);
-	}
-	const up = "../".repeat(patternToPagePath(pattern).split("/").length);
-	return `---
-// Shared collection routes: ${routes.map((r) => r.id).join(", ")}
-${routes.map((r, i) => `import Layout${i} from '${up}layouts/${pascalCase(r.family)}.astro'\nimport data${i} from '${up}data/${r.collection ?? "posts"}.json'`).join("\n")}
-import { postMarks${seo ? ", postSeo" : ""}, type EmittedPost } from '${up}lib/fill'
-export function getStaticPaths() {
-  const sources = [${routes.map((_, i) => `data${i}`).join(", ")}] as EmittedPost[][]
-  const seen = new Set<string>()
-  return sources.flatMap((posts, routeIndex) => posts.map(post => {
-    const key = decodeURIComponent(post.slug).replace(/\\/+$/, '')
-    if (seen.has(key)) throw new Error('Route collision in shared collections: ' + post.slug)
-    seen.add(key)
-    return { params: { ...(post.params ?? {}), slug: post.slug }, props: { post, routeIndex } }
-  }))
+  /** Per-page SEO — see src/components/Seo.astro. */
+  seo?: SeoInput` : ""}
 }
-const { post, routeIndex } = Astro.props as { post: EmittedPost, routeIndex: number }
-const layouts = [${routes.map((_, i) => `Layout${i}`).join(", ")}]
-const locales = ${JSON.stringify(routes.map((r) => r.locale ?? siteLocale))}
-const Layout = layouts[routeIndex]!
----
-<Layout title={post.title} marks={postMarks(post)} body={post.body}
-  css={post.css ?? []} lang={post.locale ?? locales[routeIndex]} entry={post.entry}${seo ? " seo={postSeo(post)}" : ""} />
+const { title = '', marks = {}, body, css = [], lang = ${JSON.stringify(lang)}${mounts.length ? ", entry" : ""}${seoOn ? ", seo" : ""} } = Astro.props
+const head = renderTemplate(chrome.head, marks)
+// Root attributes carry the theme's layout hooks; values may hold @@marks@@.
+// An explicit lang from the source wins over the project default.
+const htmlAttrs = { lang, ...fillAttrs(chrome.html_attrs, marks) }
+const bodyAttrs = fillAttrs(chrome.body_attrs, marks)
+${options.images ? `// Content images get srcset, WebP, size and lazy loading at build time; the
+// theme chrome around them is left as the source had it.
+const content = await optimizeHtmlImages(body ?? (Astro.slots.has('default') ? await Astro.slots.render('default') : ''))` : `const content = body ?? (Astro.slots.has('default') ? await Astro.slots.render('default') : '')`}
+// Split at the marker FIRST, then fill marks per side — filling first would
+// eat the @@body@@ inside the marker and silently drop the content.
+const html = composeBody(chrome.body, marks, content)
+${queryRender}${mountTable}---
+<!doctype html>
+<html {...htmlAttrs}>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+${cssLinks.split("\n").filter(Boolean).map((l) => `    ${l}`).join("\n")}
+    {css.map((file) => (
+      <link rel="stylesheet" href={cssHref(file)} />
+    ))}
+    <Fragment set:html={head} />
+${seoOn ? `    <Seo title={title} locale={lang}${siteNameProp}${websiteIdProp}${publisherIdProp}${trailingSlashProp}${robotsProp}${headLdIdsProp} {...(seo ?? {})} />` : `    <title>{title}</title>`}
+  </head>
+  <body {...bodyAttrs}>
+${renderRefs("header") ? `${renderRefs("header")}\n` : ""}${bodyRender}
+${renderRefs("footer") ? `${renderRefs("footer")}\n` : ""}  </body>
+</html>
 `;
+	return {
+		files,
+		warnings
+	};
 }
 //#endregion
 //#region src/embed.ts
@@ -1467,13 +2650,39 @@ export interface EntryRef {
 
 export class EmbedError extends Error {
   status: number
-  constructor(status: number, message: string) {
+  /** The API's machine code (\`data.code\`), when the body carries one — e.g. \`payment_required\`. */
+  code?: string
+  constructor(status: number, message: string, code?: string) {
     super(message)
     this.name = 'EmbedError'
     this.status = status
+    if (code) this.code = code
   }
 }
 
+/**
+ * The workspace's subscription is inactive (Studio answers 402
+ * \`payment_required\` on the public forms and comments endpoints). Not the
+ * visitor's problem and not transient: no retry helps until the owner updates
+ * billing.
+ */
+export function isPaymentRequired(error: unknown): boolean {
+  return error instanceof EmbedError && (error.status === 402 || error.code === 'payment_required')
+}
+
+/**
+ * Take a widget off the page without a word to the visitor — the message is
+ * written for the workspace owner, who finds it in the console. The rest of
+ * the page is untouched.
+ */
+export function hideUnavailable(host: HTMLElement, what: 'form' | 'comments'): void {
+  host.innerHTML = ''
+  host.hidden = true
+  // A site stylesheet that sets display on the element would override hidden.
+  host.style.display = 'none'
+  console.debug('[contentrain] ' + what + ' hidden: the workspace subscription is inactive (402 payment_required). The workspace owner needs to update billing in Contentrain Studio.')
+}
+
 /**
  * Visitor-facing text. The component passes the page's text from the site's
  * ui-strings dictionary (\`data-strings\`); these are the defaults it falls
@@ -1526,14 +2735,16 @@ export function publicUrl(base: string, segments: string[], query?: Record<strin
 async function failure(res: Response): Promise<EmbedError> {
   const text = await res.text().catch(() => '')
   let message = text || 'Request failed'
+  let code: string | undefined
   try {
-    const parsed = JSON.parse(text) as { message?: unknown; statusMessage?: unknown }
+    const parsed = JSON.parse(text) as { message?: unknown; statusMessage?: unknown; data?: { code?: unknown } }
     const m = parsed.message ?? parsed.statusMessage
     if (typeof m === 'string' && m) message = m
+    if (typeof parsed.data?.code === 'string') code = parsed.data.code
   } catch {
     // not JSON — the raw text is the message
   }
-  return new EmbedError(res.status, message)
+  return new EmbedError(res.status, message, code)
 }
 
 export async function getJson<T>(url: string): Promise<T> {
@@ -2051,6 +3262,7 @@ export async function mountForm(host: HTMLElement): Promise<void> {
   try {
     config = await fetchFormConfig(rt, model)
   } catch (error) {
+    if (isPaymentRequired(error)) return hideUnavailable(host, 'form')
     host.innerHTML = '<p class="cr-error">' + esc(error instanceof Error ? error.message : strings.failed) + '</p>'
     return
   }
@@ -2071,6 +3283,7 @@ export async function mountForm(host: HTMLElement): Promise<void> {
       setStatus(form, errorsHtml(result.errors ?? []))
       resetCaptcha(form)
     } catch (error) {
+      if (isPaymentRequired(error)) return hideUnavailable(host, 'form')
       setStatus(form, '<p class="cr-error" role="alert">' + esc(error instanceof Error ? error.message : strings.failed) + '</p>')
       resetCaptcha(form)
     } finally {
@@ -2089,6 +3302,7 @@ export async function mountComments(host: HTMLElement): Promise<void> {
   try {
     thread = await fetchThread(rt, entry)
   } catch (error) {
+    if (isPaymentRequired(error)) return hideUnavailable(host, 'comments')
     host.innerHTML = '<p class="cr-error">' + esc(error instanceof Error ? error.message : strings.failed) + '</p>'
     return
   }
@@ -2138,6 +3352,9 @@ export async function mountComments(host: HTMLElement): Promise<void> {
         const list = threadEl.querySelector('.cr-comment-list')
         if (list) list.insertAdjacentHTML('beforeend', next.comments.map((c) => commentHtml(c, next.config)).join(''))
         if (!hasMore(next)) more.closest('.cr-more')?.remove()
+      } catch (error) {
+        if (isPaymentRequired(error)) return hideUnavailable(host, 'comments')
+        // Anything else: the button comes back for another try.
       } finally {
         more.disabled = false
       }
@@ -2179,6 +3396,7 @@ export async function mountComments(host: HTMLElement): Promise<void> {
       resetCaptcha(form)
       setStatus(form, '<p class="cr-success" role="status">' + esc(result.status === 'approved' ? strings.posted : strings.pending) + '</p>')
     } catch (error) {
+      if (isPaymentRequired(error)) return hideUnavailable(host, 'comments')
       setStatus(form, '<p class="cr-error" role="alert">' + esc(error instanceof Error ? error.message : strings.failed) + '</p>')
       resetCaptcha(form)
     } finally {
@@ -2524,143 +3742,377 @@ function chromeComponents(families) {
 	};
 }
 //#endregion
-//#region src/alternates.ts
+//#region src/css.ts
+const LEADING = /^(\s*(?:@charset[^;]+;|@import[^;]+;|\/\*[\s\S]*?\*\/)\s*)+/;
+function wrapLegacyCss(path, css) {
+	const rest = css.replace(LEADING, "");
+	if (/@import\s/.test(rest)) return {
+		content: css,
+		warning: `${path}: @import after other rules — left unwrapped (fix the source stylesheet; mid-file imports are ignored by browsers)`
+	};
+	return { content: `${css.slice(0, css.length - rest.length).replace(/@import\s+([^;]+);/g, (full, spec) => /\blayer\s*\(/.test(spec) ? full : `@import ${spec.trim()} layer(${LEGACY_CSS_LAYER});`)}@layer ${LEGACY_CSS_LAYER} {\n${rest}\n}\n` };
+}
+//#endregion
+//#region src/redirects.ts
+/** The statuses written to `astro.config`; any other is a manual rule. */
+const REDIRECT_STATUSES = [
+	301,
+	302,
+	307,
+	308
+];
+/** 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) {
+	return path === "/" ? "/" : `${path.replace(/\/+$/, "")}/`;
+}
 /**
-* The path Astro builds for a route pattern and a set of parameters, in the
-* directory format the scaffold configures (`/en/hello/`). Null when a
-* parameter has no value — that page has no address to name.
+* Every address the emitted site builds a page at, as `addressKey`s, with the
+* route that owns it. Single and collection routes build one page per entry,
+* query routes one per result set, and a route without parameters one page.
 */
-function entryPath(pattern, params) {
-	const segments = pattern.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
-	if (!segments.length) return "/";
-	const out = [];
-	for (const segment of segments) {
-		if (!segment.startsWith(":")) {
-			out.push(segment);
+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);
+	};
+	for (const route of routes) {
+		const pagePath = patternToPagePath(route.pattern);
+		if (!pagePath) continue;
+		if (!pagePath.includes("[")) {
+			put(entryPath(route.pattern, {}), route.id);
 			continue;
 		}
-		const value = params[segment.slice(1).replace(/\*$/, "")]?.replace(/^\/+|\/+$/g, "");
-		if (!value) return null;
-		out.push(value);
+		if (route.kind === "single" || route.collection !== void 0) for (const post of collectionItems(content, route.collection ?? "posts")) put(entryPath(route.pattern, {
+			...post.params,
+			slug: post.slug
+		}), route.id);
+		if (route.query) for (const page of content.queries?.[route.query] ?? []) put(entryPath(route.pattern, page.params), route.id);
+	}
+	return out;
+}
+/** The decoded path for a literal Astro redirect key, or why `from` cannot be one. */
+function checkFrom(from) {
+	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;
+	try {
+		path = decodeURI(from);
+	} catch {
+		return { reason: "from is not a valid percent-encoded path" };
+	}
+	if (hasControlOrSpace(path) || path.includes("\\")) return { reason: "from contains whitespace, control characters or a backslash" };
+	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" };
+	return { path };
+}
+function checkTo(to) {
+	if (hasControlOrSpace(to)) return false;
+	if (to.startsWith("/")) return !to.startsWith("//");
+	try {
+		const url = new URL(to);
+		return url.protocol === "https:" || url.protocol === "http:";
+	} catch {
+		return false;
 	}
-	return `/${out.join("/")}/`;
 }
-const byLangTag = (a, b) => a.lang < b.lang ? -1 : a.lang > b.lang ? 1 : 0;
 /**
-* Attach `alternates` to every entry that has translations on the site.
-*
-* The language of a page is the one its `<html lang>` gets: the post's own
-* locale, else its route's, else the site's. A site with one language has no
-* alternates and nothing is attached.
+* Split the rules into what `astro.config` serves and what the host has to.
+* `built` is `builtAddresses` of the emitted routes.
 */
-function withAlternates(routes, content, siteLocale) {
-	const warnings = [];
-	const placements = /* @__PURE__ */ new Map();
-	for (const route of routes) {
-		if (route.kind !== "single" && route.collection === void 0) continue;
-		const pagePath = patternToPagePath(route.pattern);
-		if (!pagePath) continue;
-		const collection = route.collection ?? "posts";
-		const posts = collectionItems(content, collection);
-		if (!pagePath.includes("[") && posts.length !== 1) continue;
-		for (const post of posts) {
-			const list = placements.get(post) ?? [];
-			list.push({
-				lang: post.locale ?? route.locale ?? siteLocale,
-				path: entryPath(route.pattern, {
-					...post.params,
-					slug: post.slug
-				}),
-				key: post.entry ? JSON.stringify([post.entry.model_id, post.entry.entry_id]) : void 0,
-				collection
-			});
-			placements.set(post, list);
+function planRedirects(redirects, built) {
+	const config = {};
+	const written = [];
+	const manual = [];
+	const claimed = /* @__PURE__ */ new Set();
+	const builtLower = new Map([...built].map(([address, route]) => [address.toLowerCase(), [address, route]]));
+	for (const redirect of redirects) {
+		const skip = (reason) => manual.push({
+			redirect,
+			reason
+		});
+		if (redirect.regex) {
+			skip("from is a regular expression");
+			continue;
 		}
-	}
-	if (new Set([...placements.values()].flat().map((p) => p.lang)).size < 2) return {
-		content,
-		warnings
-	};
-	const groups = /* @__PURE__ */ new Map();
-	const unkeyed = /* @__PURE__ */ new Map();
-	const ambiguous = /* @__PURE__ */ new Map();
-	for (const [post, list] of placements) {
-		const first = list[0];
-		if (list.length > 1 || first.path === null) {
-			ambiguous.set(first.collection, (ambiguous.get(first.collection) ?? 0) + 1);
+		if (redirect.match !== void 0 && redirect.match !== "url") {
+			skip(`match "${redirect.match}" is a pattern, not one address`);
 			continue;
 		}
-		if (!first.key) {
-			unkeyed.set(first.collection, (unkeyed.get(first.collection) ?? 0) + 1);
+		const status = redirect.status ?? 301;
+		if (!REDIRECT_STATUSES.includes(status)) {
+			skip(`status ${status} is not one of ${REDIRECT_STATUSES.join("/")}`);
 			continue;
 		}
-		const group = groups.get(first.key) ?? [];
-		group.push({
-			post,
-			lang: first.lang,
-			path: first.path
-		});
-		groups.set(first.key, group);
-	}
-	for (const [collection, count] of unkeyed) warnings.push(`collection ${collection}: ${count} posts carry no entry address — hreflang cannot link them to their translations`);
-	for (const [collection, count] of ambiguous) warnings.push(`collection ${collection}: ${count} posts have no single address (served by more than one route, or a route parameter without a value) — no hreflang on those pages`);
-	const alternatesOf = /* @__PURE__ */ new Map();
-	for (const group of groups.values()) {
-		if (group.length < 2) continue;
-		const byLang = /* @__PURE__ */ new Map();
-		let conflict = false;
-		for (const member of group) {
-			const seen = byLang.get(member.lang);
-			if (seen !== void 0 && seen !== member.path) conflict = true;
-			byLang.set(member.lang, member.path);
+		const from = checkFrom(redirect.from);
+		if ("reason" in from) {
+			skip(from.reason);
+			continue;
 		}
-		const entry = group[0].post.entry;
-		if (conflict) {
-			warnings.push(`entry ${entry.model_id}/${entry.entry_id}: two pages claim the same language — no hreflang for this entry`);
+		if (!checkTo(redirect.to)) {
+			skip("to is not a site-root path or an http(s) URL");
 			continue;
 		}
-		if (byLang.size < 2) continue;
-		const alternates = [...byLang].map(([lang, path]) => ({
-			lang,
-			path
-		})).toSorted(byLangTag);
-		const fallback = byLang.get(siteLocale);
-		if (fallback !== void 0) alternates.push({
-			lang: "x-default",
-			path: fallback
-		});
-		for (const member of group) alternatesOf.set(member.post, alternates);
+		const key = addressKey$1(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`);
+			continue;
+		}
+		const caseTwin = builtLower.get(key.toLowerCase());
+		if (caseTwin) {
+			skip(`from differs only in letter case from the page at ${caseTwin[0]} (route ${caseTwin[1]}) — a case-insensitive host or file system would serve the redirect over it; the page is kept`);
+			continue;
+		}
+		if (claimed.has(key)) {
+			skip(`another rule already redirects ${key}`);
+			continue;
+		}
+		if (!/^https?:/.test(redirect.to)) {
+			let target;
+			try {
+				target = decodeURI(redirect.to.replace(/[?#].*$/, ""));
+			} catch {
+				target = redirect.to;
+			}
+			if (addressKey$1(target) === key) {
+				skip("to is the same address as from");
+				continue;
+			}
+		}
+		claimed.add(key);
+		config[from.path] = {
+			status,
+			destination: redirect.to
+		};
+		written.push(redirect);
 	}
-	if (!alternatesOf.size) return {
-		content,
-		warnings
+	return {
+		config: Object.fromEntries(Object.entries(config).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)),
+		written,
+		manual
 	};
-	const mark = (posts) => posts.map((post) => {
-		const alternates = alternatesOf.get(post);
-		return alternates ? {
-			...post,
-			alternates
-		} : post;
-	});
+}
+/** The `redirects` line for astro.config.mjs, or null when there is nothing to write. */
+function astroRedirectsConfig(config) {
+	const entries = Object.entries(config);
+	if (!entries.length) return null;
+	return [
+		`  redirects: {`,
+		...entries.map(([from, rule]) => `    ${JSON.stringify(from)}: { status: ${rule.status}, destination: ${JSON.stringify(rule.destination)} },`),
+		`  },`
+	].join("\n");
+}
+/**
+* Cloudflare Pages takes 2,000 static rules, Vercel 2,048 redirects; each
+* rule is written twice (with and without its trailing slash).
+*/
+const HOST_RULE_LIMIT = 2e3;
+/** Netlify reads `:name` and `*` in a rule as placeholders. */
+const HOST_PATTERN_CHAR = /(?:^|\/):|\*/;
+/** path-to-regexp (vercel.json `source`): escape what it would read as syntax. */
+const escapePathPattern = (s) => s.replace(/[:()*+?{}\\]/g, (c) => `\\${c}`);
+/** A path as a host matches it: percent-encoded, with and without the trailing slash. */
+function hostSources(path) {
+	const encoded = encodeURI(path);
+	if (encoded === "/") return ["/"];
+	const bare = encoded.replace(/\/+$/, "");
+	return [bare, `${bare}/`];
+}
+/**
+* Real HTTP redirects for the host the site deploys to. A static Astro build
+* serves `redirects` as meta-refresh pages; the status code only exists if the
+* host answers the request itself, from its own redirect file. The
+* meta-refresh pages stay as the fallback for a host without one.
+*
+* - `netlify` — `public/_redirects`, forced (`301!`): the build writes a page
+*   at every redirected path, and Netlify serves an existing file before an
+*   unforced rule.
+* - `cloudflare` — `public/_redirects`, unforced: Cloudflare Pages has no `!`
+*   and applies its rules before static assets.
+* - `vercel` — `vercel.json` `redirects`, which Vercel applies before the
+*   filesystem.
+*
+* Without a host both the Netlify file and `vercel.json` are written; a site
+* on Cloudflare Pages should name its host.
+*/
+function hostRedirectFiles(config, host) {
+	const entries = Object.entries(config);
+	const skipped = entries.filter(([from]) => HOST_PATTERN_CHAR.test(from)).map(([from]) => from);
+	const rules = entries.filter(([from]) => !skipped.includes(from));
+	if (!rules.length) return {
+		files: {},
+		written: [],
+		skipped,
+		over_limit: []
+	};
+	const limited = rules.slice(0, Math.floor(HOST_RULE_LIMIT / 2));
+	const overLimit = host === "netlify" ? [] : rules.slice(limited.length).map(([from]) => from);
+	const files = {};
+	const written = [];
+	const redirectsFile = (force, list) => [
+		"# Emitted by @contentrain/emitter-astro — the source site's redirects, as real HTTP redirects.",
+		...list.flatMap(([from, rule]) => hostSources(from).map((source) => `${source} ${rule.destination} ${rule.status}${force ? "!" : ""}`)),
+		""
+	].join("\n");
+	if (host === void 0 || host === "netlify") {
+		files["public/_redirects"] = redirectsFile(true, rules);
+		written.push("public/_redirects (netlify)");
+	}
+	if (host === "cloudflare") {
+		files["public/_redirects"] = redirectsFile(false, limited);
+		written.push("public/_redirects (cloudflare)");
+	}
+	if (host === void 0 || host === "vercel") {
+		const redirects = limited.flatMap(([from, rule]) => hostSources(from).map((source) => ({
+			source: escapePathPattern(source),
+			destination: rule.destination,
+			statusCode: rule.status
+		})));
+		files["vercel.json"] = `${JSON.stringify({ redirects }, null, 2)}\n`;
+		written.push("vercel.json (vercel)");
+	}
 	return {
-		content: {
-			...content,
-			...content.posts ? { posts: mark(content.posts) } : {},
-			...content.collections ? { collections: Object.fromEntries(Object.entries(content.collections).map(([name, posts]) => [name, mark(posts)])) } : {}
-		},
-		warnings
+		files,
+		written,
+		skipped,
+		over_limit: overLimit
 	};
 }
 //#endregion
-//#region src/css.ts
-const LEADING = /^(\s*(?:@charset[^;]+;|@import[^;]+;|\/\*[\s\S]*?\*\/)\s*)+/;
-function wrapLegacyCss(path, css) {
-	const rest = css.replace(LEADING, "");
-	if (/@import\s/.test(rest)) return {
-		content: css,
-		warning: `${path}: @import after other rules — left unwrapped (fix the source stylesheet; mid-file imports are ignored by browsers)`
+//#region src/seo-entry.ts
+/**
+* A plugin's unrendered template, in its own syntax: Yoast `%%title%%`,
+* SEOPress `%%post_title%%`, Rank Math `%title%` / `%customfield(name)%`,
+* AIOSEO `#post_title`. Printed as-is it would be a literal
+* `%%title%% %%sep%%` in the search result, so such a value is dropped and
+* the page's own falls in. AIOSEO's tags are matched by name, not as any
+* `#word`: a title can hold a hashtag.
+*/
+const TEMPLATE_RE = {
+	yoast: /%%[a-z0-9_-]+%%/i,
+	seopress: /%%[a-z0-9_-]+%%/i,
+	rank_math: /%[a-z_]+(?:\([^)]*\))?%/i,
+	aioseo: /#(?:(?:alt|archive|attachment|author|category|current|custom_field|page|parent|post|search|separator|site|tax|taxonomy)_[a-z0-9_-]+|categories|permalink|tagline)\b/i
+};
+/**
+* Whether a string holds a template token. Percent-encoding is decoded first
+* when it decodes: `%E4%B8%AD` in a CJK URL is text, not Rank Math's `%AD%`.
+* A real token never decodes (`%ti…` is no escape), so it is tested as it is.
+*/
+function hasToken(value, template) {
+	let decoded = value;
+	try {
+		decoded = decodeURI(value);
+	} catch {}
+	return template.test(decoded);
+}
+const text = (value, template) => {
+	const v = value?.trim();
+	if (!v) return void 0;
+	return template && hasToken(v, template) ? void 0 : v;
+};
+const addressKey = (url) => url.trim().replace(/^https?:\/\//i, "//").replace(/\/+(?=[?#]|$)/, "");
+function social(value, template) {
+	if (!value) return void 0;
+	const out = {};
+	const title = text(value.title, template);
+	const description = text(value.description, template);
+	const image = value.image?.trim();
+	const card = value.card?.trim();
+	if (title) out.title = title;
+	if (description) out.description = description;
+	if (image) out.image = image;
+	if (card) out.card = card;
+	return Object.keys(out).length ? out : void 0;
+}
+/** Share-card values: the rendered ones, each missing one from the block. */
+function merged(rendered, stored) {
+	if (!rendered) return stored;
+	if (!stored) return rendered;
+	return {
+		...stored,
+		...rendered
 	};
-	return { content: `${css.slice(0, css.length - rest.length).replace(/@import\s+([^;]+);/g, (full, spec) => /\blayer\s*\(/.test(spec) ? full : `@import ${spec.trim()} layer(${LEGACY_CSS_LAYER});`)}@layer ${LEGACY_CSS_LAYER} {\n${rest}\n}\n` };
+}
+/**
+* One page's SEO fields from the blocks each plugin holds for it. The serving
+* plugin's block wins; without one the first plugin (Yoast, Rank Math,
+* AIOSEO, SEOPress) that has data does. Its values are read, in order, from:
+*
+* 1. the block itself when the running plugin rendered it (`resolved`);
+* 2. `rendered` — the exporter's own rendering of the plugin's templates, for
+*    a plugin that is not the one serving the head. Final text: a variable it
+*    could not render is already out of the string, and only listed in
+*    `unresolved` for a person to read;
+* 3. the stored values, with the plugin's unrendered templates dropped.
+*
+* 2 and 3 are taken field by field: a value the rendering does not carry
+* falls back to the block's stored literal.
+*
+* Whatever the source, a string that still holds a template token in the
+* plugin's syntax is dropped: a token is never printed. The same holds for
+* the JSON-LD: a resolved block's graph is the plugin's rendering; any other
+* block's graph — the exporter's rendered nodes, else its own top-level graph
+* — is read node by node, and a node still holding a token is left out.
+*
+* Robots come from `robots_served` — what the page actually carried after
+* WordPress and the plugin reconciled their settings — then `rendered.robots`,
+* then the plugin's own `robots`.
+*/
+function seoFromRawEntry(blocks, options = {}) {
+	if (!blocks) return {};
+	const provider = [...options.serving && options.serving !== "wordpress-core" ? [options.serving] : [], ...SEO_PROVIDERS].find((p) => blocks[p] !== void 0);
+	if (!provider) return {};
+	const entry = blocks[provider];
+	const template = entry.resolved === true ? void 0 : TEMPLATE_RE[provider];
+	const rendered = entry.resolved === true ? void 0 : entry.rendered;
+	const out = {};
+	const title = text(rendered?.title, template) ?? text(entry.title, template);
+	if (title) out.seo_title = title;
+	const description = text(rendered?.description, template) ?? text(entry.description, template);
+	if (description) out.description = description;
+	const canonical = (rendered?.canonical ?? entry.canonical)?.trim();
+	if (canonical && !(options.url && addressKey(canonical) === addressKey(options.url))) out.canonical = canonical;
+	const served = entry.robots_served?.map((d) => d.trim().toLowerCase());
+	const robots = rendered?.robots ?? entry.robots;
+	const noindex = served ? served.includes("noindex") : robots?.index === "noindex";
+	const nofollow = served ? served.includes("nofollow") : robots?.follow === "nofollow";
+	if (noindex) out.noindex = true;
+	if (nofollow) out.nofollow = true;
+	const og = merged(social(rendered?.open_graph, template), social(entry.open_graph, template));
+	if (og) out.open_graph = og;
+	const tw = merged(social(rendered?.twitter, template), social(entry.twitter, template));
+	if (tw) out.twitter = tw;
+	if (entry.resolved === true) {
+		const graph = entry.schema?.graph;
+		if (graph && typeof graph === "object") out.schema = graph;
+	} else if (template) {
+		const top = entry.schema?.graph;
+		const nodes = (Array.isArray(rendered?.schema?.graph) ? rendered.schema.graph : ldNodes(top)).filter((node) => !holdsToken(node, template));
+		if (nodes.length) out.schema = {
+			"@context": "https://schema.org",
+			"@graph": nodes
+		};
+	}
+	return out;
+}
+/** A JSON-LD value's nodes: a @graph object's graph, a node array, or one node. */
+function ldNodes(value) {
+	if (!value || typeof value !== "object") return [];
+	if (Array.isArray(value)) return value;
+	const graph = value["@graph"];
+	return Array.isArray(graph) ? graph : [value];
+}
+/** Whether any string anywhere in a JSON value holds a template token. */
+function holdsToken(value, template) {
+	if (typeof value === "string") return hasToken(value, template);
+	if (Array.isArray(value)) return value.some((v) => holdsToken(v, template));
+	if (value && typeof value === "object") return Object.values(value).some((v) => holdsToken(v, template));
+	return false;
 }
 //#endregion
 //#region src/index.ts
@@ -2671,6 +4123,31 @@ function wrapLegacyCss(path, css) {
 function badTrail(trail) {
 	return trail !== void 0 && !(trail.length > 0 && trail.every((c) => typeof c?.name === "string" && c.name.trim() !== "" && typeof c.path === "string" && !c.path.includes(String.fromCharCode(92)) && ![...c.path].some((char) => char.charCodeAt(0) <= 32) && /^\/(?!\/)/.test(c.path)));
 }
+/**
+* A source JSON-LD value the Seo component cannot print (see
+* `sourceStructuredData`): not an object, or no node in it names a type.
+*/
+function badSchema(schema) {
+	if (schema === void 0) return false;
+	if (!schema || typeof schema !== "object") return true;
+	const graph = schema["@graph"];
+	return !(Array.isArray(schema) ? schema : Array.isArray(graph) ? graph : [schema]).some((n) => {
+		const type = n && typeof n === "object" && !Array.isArray(n) ? n["@type"] : void 0;
+		return (Array.isArray(type) ? type : [type]).some((t) => typeof t === "string");
+	});
+}
+/** Redirect config sorted by `from`, the order astro.config and the host files list it in. */
+function sortedConfig(config) {
+	return Object.fromEntries(Object.entries(config).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+}
+/** A redirect's from as its config key: percent-encoding decoded, as planRedirects writes it. */
+function decodedPath(from) {
+	try {
+		return decodeURI(from);
+	} catch {
+		return from;
+	}
+}
 function emitAstroProject(input) {
 	const { ir } = input;
 	const warnings = [];
@@ -2684,8 +4161,70 @@ function emitAstroProject(input) {
 			files[path] = content;
 		}
 	};
-	add(scaffoldFiles(ir, input.options ?? {}));
+	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;
+	const llmsOn = input.options?.llms !== false && linkable.length > 0;
+	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 seo = input.options?.seo !== false;
+	const noindex = noindexPaths(ir.routes, input.content ?? {});
+	const built = builtAddresses(ir.routes, input.content ?? {});
+	const sourceConfig = redirectPlan?.config ?? {};
+	const claimed = new Set(Object.keys(sourceConfig).map((from) => from.replace(/\/+$/, "").toLowerCase()));
+	const feedRules = [];
+	const addFeedRule = (from, to) => {
+		const key = from.replace(/\/+$/, "").toLowerCase();
+		if (claimed.has(key)) return;
+		claimed.add(key);
+		feedRules.push({
+			from,
+			to,
+			status: 301
+		});
+	};
+	if (feedSource) addFeedRule(FEED_REDIRECT_FROM, FEED_PATH);
+	for (const source of archiveFeeds) for (const page of input.content?.queries?.[source.query] ?? []) {
+		const address = entryPath(source.pattern, page.params);
+		if (address) addFeedRule(`${address}feed/`, `${address}feed.xml`);
+	}
+	const feedPlan = planRedirects(feedRules, built);
+	if (feedPlan.manual.length) warnings.push(`feed: ${feedPlan.manual.length} feed redirects not written — ${feedPlan.manual.map((m) => `${m.redirect.from} (${m.reason})`).join("; ")}`);
+	const redirectConfig = {
+		...sourceConfig,
+		...feedPlan.config
+	};
+	const hasRedirects = Object.keys(redirectConfig).length > 0;
+	add(scaffoldFiles(ir, input.options ?? {}, noindex, hasRedirects ? astroRedirectsConfig(sortedConfig(redirectConfig)) : null, input.runtime));
+	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]]))
+	};
+	const hostRedirects = hasRedirects ? hostRedirectFiles(hostOrder, input.options?.redirectHost) : void 0;
+	if (hostRedirects) {
+		add(hostRedirects.files);
+		if (hostRedirects.over_limit.length) {
+			const limitedFiles = hostRedirects.written.filter((f) => !f.includes("(netlify)")).join(", ");
+			const feedOver = hostRedirects.over_limit.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`);
+		}
+		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 (input.options?.trailingSlash === false && (input.options.redirectHost ?? "vercel") === "vercel") {
+		const vercel = files["vercel.json"] ? JSON.parse(files["vercel.json"]) : {};
+		files["vercel.json"] = `${JSON.stringify({
+			cleanUrls: true,
+			trailingSlash: false,
+			...vercel
+		}, null, 2)}\n`;
+	}
+	if (noindex.length && !seo) warnings.push(`${noindex.length} noindex pages: options.seo is false, so no robots meta is emitted — the producer's head must carry it (they are still left out of the sitemap)`);
 	if (seo) {
 		add({ "src/components/Seo.astro": SEO_COMPONENT });
 		if (!ir.site.url) warnings.push("site.url is empty — canonical links and absolute og:url/og:image are omitted; set it so search engines and share cards resolve");
@@ -2724,7 +4263,10 @@ function emitAstroProject(input) {
 		const fam = familyFiles(family, lang, chrome.byFamily.get(family.id), definitions, bodyMarkersByFamily.get(family.id) ?? [], {
 			seo,
 			siteName: ir.site.title,
-			boundQueries
+			boundQueries,
+			images: imagesEnabled(input.options ?? {}),
+			feedSite: feedSource ? ir.site.url : void 0,
+			trailingSlash: input.options?.trailingSlash
 		});
 		add(fam.files);
 		warnings.push(...fam.warnings);
@@ -2746,10 +4288,14 @@ function emitAstroProject(input) {
 	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 ?? {})) {
 		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 ?? {};
 	if (seo) {
@@ -2771,7 +4317,7 @@ function emitAstroProject(input) {
 	const pageOwner = /* @__PURE__ */ new Map();
 	const collisions = [];
 	for (const route of ir.routes) {
-		const result = routeFiles(route, familiesById.get(route.family), routeContent, lang, seo);
+		const result = routeFiles(route, familiesById.get(route.family), routeContent, lang, seo, archiveFeedRoutes.has(route.id));
 		for (const path of sharedPages.keys()) delete result.files[path];
 		for (const path of Object.keys(result.files)) {
 			if (!path.startsWith("src/pages/")) continue;
@@ -2813,9 +4359,32 @@ function emitAstroProject(input) {
 			if (unbound) warnings.push(`collection ${name}: ${unbound} of ${posts.length} posts carry no entry address — the comments component renders nothing on those pages`);
 		}
 	}
+	const feedInput = {
+		ir,
+		siteLocale: lang,
+		description: input.options?.siteDescription,
+		trailingSlash: input.options?.trailingSlash !== false
+	};
+	const written = (source) => files[`src/data/${source.collection}.json`] !== void 0;
+	if (feedSource) if (written(feedSource)) add({ "src/pages/feed.xml.ts": feedEndpoint(feedSource, feedInput) });
+	else warnings.push(`feed: no posts data file was written, so no feed is built — the head's feed link points at ${FEED_PATH}, which 404s`);
+	for (const source of archiveFeeds) {
+		const file = archiveFeedFile(source.pattern);
+		if (file && feedSource && files[`src/data/queries/${source.query}.json`] !== void 0) add({ [file]: archiveFeedEndpoint(source, feedSource.pattern, feedInput) });
+	}
+	if (llmsOn) {
+		const listed = linkable.filter(written);
+		if (listed.length) add({ "src/pages/llms.txt.ts": llmsEndpoint(listed, feedInput) });
+	}
 	return {
 		files,
-		warnings
+		warnings,
+		...redirectPlan ? { redirects: {
+			written: redirectPlan.written,
+			manual: redirectPlan.manual,
+			host_files: hostRedirects?.written ?? [],
+			host_over_limit: hostRedirects?.over_limit ?? []
+		} } : {}
 	};
 }
 /**
@@ -2838,6 +4407,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, RUNTIME_IMPLEMENTED, SEO_COMPONENT, UI_STRINGS_DIR, UI_STRINGS_MODEL, UI_STRING_DEFAULTS, balanceWarning, bodySeoLeaks, checkBalance, componentMarkers, emitAstroProject, entryPath, isRuntimeImplemented, pascalCase, patternToPagePath, 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, hostRedirectFiles, isRuntimeImplemented, linkSources, noindexPaths, pascalCase, patternToPagePath, planRedirects, publisherIdOf, rewriteFeedLinks, seoFromRawEntry, stableJson, stripSeoTags, websiteIdOf, withAlternates, wrapLegacyCss, writeEmit };
 
 //# sourceMappingURL=index.mjs.map