@contentrain/emitter-astro 0.13.0 → 0.14.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { CHROME_BODY_SLOT, CHROME_COMPONENT_CLOSE, CHROME_COMPONENT_OPEN, LEGACY_CSS_LAYER } from "@contentrain/types";
+import { CHROME_BODY_SLOT, CHROME_COMPONENT_CLOSE, CHROME_COMPONENT_OPEN, DICTIONARY_TITLE_FIELD, LEGACY_CSS_LAYER } from "@contentrain/types";
 //#region src/types.ts
 /** Default collection name when a `single` route does not name one. */
 const DEFAULT_COLLECTION = "posts";
@@ -47,6 +47,7 @@ function stableJson(value) {
 function scaffoldFiles(ir, options) {
 	const tailwind = options.tailwind !== false;
 	const split = ir.viewport_strategy === "split";
+	const sitemap = options.sitemap !== false && Boolean(ir.site.url);
 	const files = {};
 	files["package.json"] = stableJson({
 		name: options.projectName ?? "migrated-site",
@@ -66,7 +67,8 @@ function scaffoldFiles(ir, options) {
 			...tailwind ? {
 				tailwindcss: "^4.0.0",
 				"@tailwindcss/vite": "^4.0.0"
-			} : {}
+			} : {},
+			...sitemap ? { "@astrojs/sitemap": "^3.7.0" } : {}
 		},
 		devDependencies: {
 			"@astrojs/check": "^0.9.0",
@@ -76,10 +78,12 @@ function scaffoldFiles(ir, options) {
 	files["astro.config.mjs"] = [
 		`import { defineConfig } from 'astro/config'`,
 		...tailwind ? [`import tailwindcss from '@tailwindcss/vite'`] : [],
+		...sitemap ? [`import sitemap from '@astrojs/sitemap'`] : [],
 		``,
 		`export default defineConfig({`,
-		`  site: ${JSON.stringify(ir.site.url)},`,
+		...ir.site.url ? [`  site: ${JSON.stringify(ir.site.url)},`] : [],
 		`  build: { format: 'directory' },`,
+		...sitemap ? [`  integrations: [sitemap()],`] : [],
 		...tailwind ? [`  vite: { plugins: [tailwindcss()] },`] : [],
 		`})`,
 		``
@@ -94,9 +98,34 @@ function scaffoldFiles(ir, options) {
 		]
 	}, null, 2)}\n`;
 	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;
 	return files;
 }
+/**
+* `robots.txt` allowing crawlers and naming the sitemap.
+*
+* The `Sitemap:` line must be an absolute URL — a relative one is invalid and
+* crawlers ignore it. Without a site to make it absolute the line is left out
+* rather than pointed at a build host; the emitter warns about the missing site
+* separately.
+*
+* Nothing is disallowed. A WordPress robots.txt typically keeps crawlers out of
+* `/wp-admin/`; the migrated site has no such path, so carrying the rule over
+* would only restrict a site that no longer needs restricting.
+*
+* The sitemap is resolved under the site's own path, not the host root: a site
+* at `https://example.com/blog` serves its build output, sitemap included, under
+* `/blog/`.
+*/
+function robotsTxt(siteUrl) {
+	const lines = ["User-agent: *", "Allow: /"];
+	if (siteUrl) {
+		const base = siteUrl.endsWith("/") ? siteUrl : `${siteUrl}/`;
+		lines.push("", `Sitemap: ${new URL("sitemap-index.xml", base).href}`);
+	}
+	return `${lines.join("\n")}\n`;
+}
 /** Tailwind 4 evolution layer: CSS-first config with the site's extracted tokens. */
 function modernCss(tokens) {
 	const lines = [`@import 'tailwindcss';`, ``];
@@ -274,6 +303,10 @@ export function renderSections<T>(
  * region has no route to distinguish them, so exactly one is expected and
  * anything else is a build error rather than a guess: picking the first would
  * silently render one category's posts under every category.
+ *
+ * Without item markup the region gets the same plain list a list page does,
+ * and the emitter has warned. An empty string here was a region that vanished
+ * from every page with nothing anywhere saying so.
  */
 export function renderQuery(pages: EmittedQueryPage[], id: string): string {
   if (pages.length !== 1) {
@@ -282,10 +315,22 @@ export function renderQuery(pages: EmittedQueryPage[], id: string): string {
       + pages.length + '. A region has no route parameter to choose between them.',
     )
   }
-  const page = pages[0]!
-  const sections = page.sections ?? (page.item_template ? [{ template: page.item_template }] : [])
-  if (!sections.length) return ''
-  return renderSections(sections, page.items, postMarks)
+  return renderQueryPage(pages[0]!)
+}
+
+/**
+ * One result set as markup: its sections, its single item template, or — when
+ * the producer supplied neither — a plain list of links. The plain list is not
+ * fidelity and the emitter warns wherever it will be used; it exists so the
+ * items are still there, because a list that renders nothing looks like a list
+ * with no posts.
+ */
+export function renderQueryPage(page: EmittedQueryPage): string {
+  const sections = page.sections?.length ? page.sections : page.item_template ? [{ template: page.item_template }] : []
+  if (sections.length) return renderSections(sections, page.items, postMarks)
+  return '<ul class="cr-post-list">'
+    + page.items.map((item) => '<li><a href="/' + item.slug + '/">' + esc(item.title) + '</a></li>').join('')
+    + '</ul>'
 }
 
 // ─── SEO helpers ───
@@ -323,6 +368,23 @@ export function absoluteUrl(value: string | undefined, site: URL | undefined): s
   }
 }
 
+export interface ImageMeta {
+  width?: number
+  height?: number
+  type?: string
+}
+
+/**
+ * The \`og:image:*\` values worth printing. A width that is not a positive
+ * integer, or a type that is not an image MIME type, would be a wrong tag
+ * rather than a missing one, so it is dropped.
+ */
+export function imageMetaTags(meta: ImageMeta | undefined): { width?: string; height?: string; type?: string } {
+  const size = (n: unknown) => (typeof n === 'number' && Number.isInteger(n) && n > 0 ? String(n) : undefined)
+  const type = typeof meta?.type === 'string' && /^image\\/[a-z0-9.+-]+$/i.test(meta.type) ? meta.type.toLowerCase() : undefined
+  return { width: size(meta?.width), height: size(meta?.height), type }
+}
+
 /**
  * JSON-LD payload for a \`<script type="application/ld+json">\`. \`<\` is escaped
  * so a value containing \`<\/script>\` cannot close the block and inject markup.
@@ -331,6 +393,102 @@ export function jsonLd(value: unknown): string {
   return JSON.stringify(value).replace(/</g, '\\\\u003c')
 }
 
+export interface Breadcrumb {
+  name: string
+  path: string
+}
+
+/**
+ * A trail every crumb of which can be printed, or undefined. A crumb needs a
+ * name and a site-root-relative path; one bad crumb drops the trail, because a
+ * breadcrumb with a hole in it states a hierarchy the site does not have.
+ */
+export function validTrail(trail: unknown): Breadcrumb[] | undefined {
+  if (!Array.isArray(trail) || !trail.length) return undefined
+  const ok = trail.every((c) => c && typeof c === 'object'
+    && typeof (c as Breadcrumb).name === 'string' && (c as Breadcrumb).name.trim() !== ''
+    && typeof (c as Breadcrumb).path === 'string'
+    && !(c as Breadcrumb).path.includes(String.fromCharCode(92))
+    && ![...(c as Breadcrumb).path].some((char) => char.charCodeAt(0) <= 32) && /^\\/(?!\\/)/.test((c as Breadcrumb).path))
+  return ok ? (trail as Breadcrumb[]) : undefined
+}
+
+export interface PageStructuredDataInput {
+  url?: string
+  site?: URL
+  title: string
+  description?: string
+  image?: string
+  locale?: string
+  article: boolean
+  pageType?: 'WebPage' | 'CollectionPage'
+  publishedAt?: string
+  modifiedAt?: string
+  author?: string
+  siteName?: string
+  /** \`@id\` of the site's own WebSite node, when its head declares one. */
+  websiteId?: string
+  breadcrumbs?: Breadcrumb[]
+}
+
+/**
+ * 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
+ * Article whose main entity it is — linked by \`@id\` rather than repeated.
+ *
+ * The page node needs an absolute address to be anything; without \`site\`
+ * only an entry's Article remains, as before. \`isPartOf\` points at the site's
+ * own WebSite node when the kept head declares one — never at a WebSite this
+ * function invents.
+ */
+export function pageStructuredData(input: PageStructuredDataInput): Record<string, unknown> | undefined {
+  const graph: Array<Record<string, unknown>> = []
+  const { url } = input
+  const trail = url ? validTrail(input.breadcrumbs) : undefined
+  const crumbs = trail
+    ? trail.map((c) => ({ name: c.name, item: absoluteUrl(c.path, input.site) }))
+    : []
+  const breadcrumbId = url && trail && crumbs.every((c) => c.item) ? url + '#breadcrumb' : undefined
+  if (url) {
+    graph.push({
+      '@type': input.pageType ?? 'WebPage',
+      '@id': url,
+      url,
+      ...(input.title ? { name: input.title } : {}),
+      ...(input.description ? { description: input.description } : {}),
+      ...(input.locale ? { inLanguage: input.locale } : {}),
+      ...(input.websiteId ? { isPartOf: { '@id': input.websiteId } } : {}),
+      ...(breadcrumbId ? { breadcrumb: { '@id': breadcrumbId } } : {}),
+    })
+  }
+  if (breadcrumbId) {
+    graph.push({
+      '@type': 'BreadcrumbList',
+      '@id': breadcrumbId,
+      itemListElement: [...crumbs, { name: input.title, item: url }].map((c, i) => ({
+        '@type': 'ListItem',
+        position: i + 1,
+        name: c.name,
+        item: c.item,
+      })),
+    })
+  }
+  if (input.article) {
+    graph.push({
+      '@type': 'Article',
+      headline: input.title,
+      ...(input.description ? { description: input.description } : {}),
+      ...(input.image ? { image: [input.image] } : {}),
+      ...(input.publishedAt ? { datePublished: input.publishedAt } : {}),
+      ...(input.modifiedAt ? { dateModified: input.modifiedAt } : {}),
+      ...(input.author ? { author: { '@type': 'Person', name: input.author } } : {}),
+      ...(url ? { mainEntityOfPage: { '@id': url } } : {}),
+      ...(input.siteName ? { publisher: { '@type': 'Organization', name: input.siteName } } : {}),
+    })
+  }
+  return graph.length ? { '@context': 'https://schema.org', '@graph': graph } : undefined
+}
+
 /** Emitted stylesheets live under /styles/legacy/ — pages reference them by file name. */
 export const cssHref = (file: string): string => '/styles/legacy/' + (file.split('/').pop() ?? file)
 
@@ -412,6 +570,10 @@ export interface SeoInput {
   description?: string
   canonical?: string
   image?: string
+  imageMeta?: ImageMeta
+  alternates?: Array<{ lang: string; path: string }>
+  breadcrumbs?: Breadcrumb[]
+  pageType?: 'WebPage' | 'CollectionPage'
   type?: 'article' | 'website'
   publishedAt?: string
   modifiedAt?: string
@@ -431,6 +593,10 @@ export function postSeo(post: EmittedPost): SeoInput {
     description: post.description ?? post.excerpt,
     canonical: post.canonical,
     image: post.image ?? featured,
+    // The measurements describe \`image\`; a \`featured\` fallback is another file.
+    imageMeta: post.image ? post.image_meta : undefined,
+    alternates: post.alternates,
+    breadcrumbs: post.breadcrumbs,
     type: 'article',
     publishedAt: post.published_at,
     modifiedAt: post.modified_at,
@@ -444,6 +610,11 @@ export interface EmittedPost extends MarkablePost {
   description?: string
   /** Social image, absolute or site-root-relative. */
   image?: string
+  image_meta?: ImageMeta
+  /** Translations of this entry, itself included, and x-default. Computed by the emitter. */
+  alternates?: Array<{ lang: string; path: string }>
+  /** Trail to this page, itself excluded. */
+  breadcrumbs?: Breadcrumb[]
   /** Canonical override; default is the page's own address. */
   canonical?: string
   /** ISO 8601, for Article structured data. */
@@ -469,7 +640,9 @@ export interface EmittedQueryPage {
   title?: string
   description?: string
   image?: string
+  image_meta?: ImageMeta
   canonical?: string
+  breadcrumbs?: Breadcrumb[]
 }
 `;
 //#endregion
@@ -593,36 +766,173 @@ function balanceWarning(html) {
 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 CANONICAL_RE = /<link\b[^>]*\brel\s*=\s*["'][^"']*\bcanonical\b[^"']*["'][^>]*>\s*/gi;
+/**
+* A translation link names the template page's translations. An RSS
+* `rel="alternate"` carries no hreflang and stays.
+*/
+const HREFLANG_RE = /<link\b(?=[^>]*\brel\s*=\s*["']?[^"'>]*\balternate\b)(?=[^>]*\bhreflang\s*=)[^>]*>\s*/gi;
 const JSONLD_RE = /<script\b[^>]*\btype\s*=\s*["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>\s*/gi;
 /**
-* Structured-data types that describe THIS page. An Organization or WebSite
-* block is site-wide and true on every page; an Article block names one post
-* and is a lie on all the others.
+* Structured data that describes THIS page. An Article names one post, a
+* WebPage (and every subtype — CollectionPage for an archive, ProfilePage for an
+* author) one address, a BreadcrumbList one page's trail: copied from the
+* template, each is a lie on every other page. Matched by suffix because
+* schema.org names its page and article subtypes that way.
 */
-const PAGE_LD_TYPES = new Set([
-	"article",
-	"blogposting",
-	"newsarticle",
-	"webpage",
+function isPageType(type) {
+	const t = type.toLowerCase();
+	return t.endsWith("page") || t.endsWith("article") || PAGE_POSTINGS.has(t);
+}
+const PAGE_POSTINGS = new Set([
 	"blogposting",
-	"techarticle"
+	"liveblogposting",
+	"socialmediaposting",
+	"discussionforumposting",
+	"breadcrumblist"
+]);
+/**
+* Structured data that describes the SITE and is true on every page. An
+* SEO plugin writes it into the same `@graph` as the page's own nodes — Yoast
+* and Rank Math put WebSite, Organization, WebPage and BreadcrumbList in one
+* block — so removing page-scoped blocks whole took the site's identity with
+* them.
+*/
+const SITE_TYPES = new Set([
+	"website",
+	"organization",
+	"corporation",
+	"localbusiness",
+	"newsmediaorganization",
+	"educationalorganization",
+	"ngo",
+	"onlinebusiness",
+	"onlinestore",
+	"governmentorganization"
 ]);
-function isPageScopedLd(json) {
+const typesOf = (node) => {
+	const type = node?.["@type"];
+	return (Array.isArray(type) ? type : [type]).filter((t) => typeof t === "string");
+};
+const isPageNode = (node) => typesOf(node).some(isPageType);
+const isSiteNode = (node) => typesOf(node).some((t) => SITE_TYPES.has(t.toLowerCase()));
+/** Every `{"@id": …}` reference anywhere inside a node. */
+function references(value, out = /* @__PURE__ */ new Set()) {
+	if (Array.isArray(value)) for (const v of value) references(v, out);
+	else if (value && typeof value === "object") {
+		const node = value;
+		if (Object.keys(node).length === 1 && typeof node["@id"] === "string") out.add(node["@id"]);
+		for (const v of Object.values(node)) references(v, out);
+	}
+	return out;
+}
+/**
+* A WebSite's SearchAction points at WordPress search (`/?s=`). A static site
+* has no search endpoint, so the claim would be false on the new site.
+*/
+function withoutSearchAction(node) {
+	const action = node["potentialAction"];
+	const actions = Array.isArray(action) ? action : action === void 0 ? [] : [action];
+	const kept = actions.filter((a) => !typesOf(a).includes("SearchAction"));
+	if (kept.length === actions.length) return {
+		node,
+		dropped: false
+	};
+	const { potentialAction: _, ...rest } = node;
+	return {
+		node: kept.length ? {
+			...rest,
+			potentialAction: Array.isArray(action) ? kept : kept[0]
+		} : rest,
+		dropped: true
+	};
+}
+/**
+* What to do with one JSON-LD block. A block with no page-scoped node stays as
+* it was. A block with one loses its page-scoped nodes and keeps the site's —
+* WebSite, Organization — together with the nodes those refer to by `@id` (a
+* logo, the person a personal site is published by), never pulling a page node
+* back in. Nothing site-scoped left means the block goes.
+*/
+function decideLd(json) {
 	let parsed;
 	try {
 		parsed = JSON.parse(json);
 	} catch {
-		return false;
+		return {
+			json: void 0,
+			kept: [],
+			droppedSearch: false
+		};
 	}
 	const graph = parsed?.["@graph"];
-	return (Array.isArray(parsed) ? parsed : Array.isArray(graph) ? graph : [parsed]).some((node) => {
-		const type = node?.["@type"];
-		return (Array.isArray(type) ? type : [type]).some((t) => typeof t === "string" && PAGE_LD_TYPES.has(t.toLowerCase()));
+	const nodes = Array.isArray(parsed) ? parsed : Array.isArray(graph) ? graph : [parsed];
+	if (!nodes.some(isPageNode)) return {
+		json: void 0,
+		kept: [],
+		droppedSearch: false
+	};
+	const byId = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		const id = node?.["@id"];
+		if (typeof id === "string") byId.set(id, node);
+	}
+	const keep = new Set(nodes.filter((n) => isSiteNode(n) && !isPageNode(n)));
+	const queue = [...keep];
+	while (queue.length) for (const id of references(queue.shift())) {
+		const target = byId.get(id);
+		if (target && !keep.has(target) && !isPageNode(target)) {
+			keep.add(target);
+			queue.push(target);
+		}
+	}
+	if (!keep.size) return {
+		json: null,
+		kept: [],
+		droppedSearch: false
+	};
+	let droppedSearch = false;
+	const kept = nodes.filter((n) => keep.has(n)).map((n) => {
+		if (!typesOf(n).some((t) => t.toLowerCase() === "website")) return n;
+		const result = withoutSearchAction(n);
+		droppedSearch ||= result.dropped;
+		return result.node;
 	});
+	const context = parsed?.["@context"];
+	const rebuilt = Array.isArray(parsed) ? kept : Array.isArray(graph) ? {
+		...context === void 0 ? {} : { "@context": context },
+		"@graph": kept
+	} : kept[0];
+	return {
+		json: JSON.stringify(rebuilt).replace(/</g, "\\u003c"),
+		kept: [...new Set(kept.flatMap(typesOf))],
+		droppedSearch
+	};
+}
+/**
+* \`@id\` of the WebSite node in a head's structured data, if it declares one
+* — the node the page's WebPage says it is part of. Only what the head says:
+* no id, no link.
+*/
+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;
+		}
+	}
 }
 /** 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 note = (label) => {
 		if (!removed.includes(label)) removed.push(label);
 	};
@@ -639,14 +949,23 @@ function stripSeoTags(html) {
 		note("canonical");
 		return "";
 	});
+	out = out.replace(HREFLANG_RE, () => {
+		note("hreflang");
+		return "";
+	});
 	out = out.replace(JSONLD_RE, (tag, json) => {
-		if (!isPageScopedLd(json)) return tag;
+		const decision = decideLd(json);
+		if (decision.json === void 0) return tag;
 		note("page-scoped JSON-LD");
-		return "";
+		if (decision.droppedSearch) note("WebSite SearchAction");
+		for (const type of decision.kept) if (!kept.includes(type)) kept.push(type);
+		if (decision.json === null) return "";
+		return `${tag.slice(0, tag.indexOf(">") + 1)}${decision.json}<\/script>\n`;
 	});
 	return {
 		html: out,
-		removed
+		removed,
+		kept
 	};
 }
 /**
@@ -682,7 +1001,7 @@ 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, jsonLd, seoDescription } from '../lib/fill'
+import { absoluteUrl, imageMetaTags, jsonLd, pageStructuredData, seoDescription, type Breadcrumb, type ImageMeta } from '../lib/fill'
 
 interface Props {
   title?: string
@@ -692,6 +1011,16 @@ interface Props {
   canonical?: string
   /** Social image: absolute, or site-root-relative. */
   image?: string
+  /** Size and type of \`image\`, as the producer measured it. */
+  imageMeta?: ImageMeta
+  /** This page's translations, itself included, plus x-default. */
+  alternates?: Array<{ lang: string; path: string }>
+  /** The trail to this page, itself excluded — the page is appended with its own address. */
+  breadcrumbs?: Breadcrumb[]
+  /** \`CollectionPage\` on a list; \`WebPage\` otherwise. */
+  pageType?: 'WebPage' | 'CollectionPage'
+  /** \`@id\` of the site's WebSite node kept in the head chrome, when there is one. */
+  websiteId?: 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. */
@@ -707,6 +1036,11 @@ const {
   description,
   canonical,
   image,
+  imageMeta,
+  alternates = [],
+  breadcrumbs,
+  pageType,
+  websiteId,
   type = 'website',
   publishedAt,
   modifiedAt,
@@ -718,33 +1052,47 @@ const {
 const site = Astro.site
 const url = canonical ? absoluteUrl(canonical, site) : absoluteUrl(Astro.url.pathname, 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)
+  return href ? [{ lang: a.lang, href }] : []
+})
+const localeAlternates = [...new Set(hreflang.map((a) => a.lang))].filter((l) => l !== 'x-default' && l !== locale)
 const desc = seoDescription(description)
 const article = type === 'article'
-const structured = article
-  ? {
-      '@context': 'https://schema.org',
-      '@type': 'Article',
-      headline: title,
-      ...(desc ? { description: desc } : {}),
-      ...(imageUrl ? { image: [imageUrl] } : {}),
-      ...(publishedAt ? { datePublished: publishedAt } : {}),
-      ...(modifiedAt ? { dateModified: modifiedAt } : {}),
-      ...(author ? { author: { '@type': 'Person', name: author } } : {}),
-      ...(url ? { mainEntityOfPage: { '@type': 'WebPage', '@id': url } } : {}),
-      ...(siteName ? { publisher: { '@type': 'Organization', name: siteName } } : {}),
-    }
-  : undefined
+const structured = pageStructuredData({
+  url,
+  site,
+  title,
+  description: desc,
+  image: imageUrl,
+  locale,
+  article,
+  pageType,
+  publishedAt,
+  modifiedAt,
+  author,
+  siteName,
+  websiteId,
+  breadcrumbs,
+})
 ---
 <title>{title}</title>
 {desc && <meta name="description" content={desc} />}
 {url && <link rel="canonical" href={url} />}
+{hreflang.map((a) => <link rel="alternate" hreflang={a.lang} href={a.href} />)}
 <meta property="og:type" content={type} />
 {title && <meta property="og:title" content={title} />}
 {desc && <meta property="og:description" content={desc} />}
 {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} />}
 {siteName && <meta property="og:site_name" content={siteName} />}
 {locale && <meta property="og:locale" content={locale} />}
+{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} />}
@@ -825,7 +1173,10 @@ function familyFiles(family, lang, components = [], definitions = /* @__PURE__ *
 	if (seoOn) {
 		const stripped = stripSeoTags(head);
 		head = stripped.html;
-		if (stripped.removed.length) warnings.push(`family ${family.id}: removed the template page's ${stripped.removed.join(", ")} from head chrome — the emitter renders these per page`);
+		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}`);
+		}
 	}
 	const files = {};
 	files[`src/data/chrome/${family.id}.json`] = stableJson({
@@ -836,6 +1187,8 @@ 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 websiteId = seoOn ? websiteIdOf(head) : void 0;
+	const websiteIdProp = websiteId ? ` websiteId={${JSON.stringify(websiteId)}}` : "";
 	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(" | ");
@@ -855,7 +1208,7 @@ const parts = splitComponents(html).map((part) => ({
   listHtml: part.component ? mounts[part.component]?.html : undefined,
 }))
 ` : "";
-	const bodyRender = mounts.length ? `    {parts.map(({ html: part, Mount, variant, listHtml }) => (Mount ? <Mount entry={entry} variant={variant} html={listHtml} /> : <Fragment set:html={part} />))}` : `    <Fragment set:html={html} />`;
+	const bodyRender = mounts.length ? `    {parts.map(({ html: part, Mount, variant, listHtml }) => (Mount ? <Mount entry={entry} variant={variant} html={listHtml} lang={htmlAttrs.lang} /> : <Fragment set:html={part} />))}` : `    <Fragment set:html={html} />`;
 	const renderRefs = (position) => components.filter((c) => c.position === position).map((c) => `    <${c.name} marks={marks} />`).join("\n");
 	files[`src/layouts/${name}.astro`] = `---
 // Family: ${family.id}${family.name ? ` (${family.name})` : ""} — emitted by @contentrain/emitter-astro
@@ -898,7 +1251,7 @@ ${cssLinks.split("\n").filter(Boolean).map((l) => `    ${l}`).join("\n")}
       <link rel="stylesheet" href={cssHref(file)} />
     ))}
     <Fragment set:html={head} />
-${seoOn ? `    <Seo title={title} locale={lang}${siteNameProp} {...(seo ?? {})} />` : `    <title>{title}</title>`}
+${seoOn ? `    <Seo title={title} locale={lang}${siteNameProp}${websiteIdProp} {...(seo ?? {})} />` : `    <title>{title}</title>`}
   </head>
   <body {...bodyAttrs}>
 ${renderRefs("header") ? `${renderRefs("header")}\n` : ""}${bodyRender}
@@ -1013,18 +1366,13 @@ const { page } = Astro.props as Props` : `const page = (data as EmittedQueryPage
 // 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 { esc, postMarks, renderSections, type EmittedQueryPage } from '${up}lib/fill'
+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 we fall back to a plain list
+// 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 sections = page.sections ?? (page.item_template ? [{ template: page.item_template }] : [])
-const content = sections.length
-  ? renderSections(sections, page.items, postMarks)
-  : '<ul class="cr-post-list">' +
-    page.items.map((item) => '<li><a href="/' + item.slug + '/">' + esc(item.title) + '</a></li>').join('') +
-    '</ul>'
+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 ?? {}) }
@@ -1036,7 +1384,7 @@ const title = page.title ?? ${routeTitle}
   body={content}
   css={page.css ?? []}
   lang={${locale}}${seo ? `
-  seo={{ description: page.description, image: page.image, canonical: page.canonical, type: 'website' }}` : ""}
+  seo={{ description: page.description, image: page.image, imageMeta: page.image_meta, canonical: page.canonical, breadcrumbs: page.breadcrumbs, type: 'website', pageType: 'CollectionPage' }}` : ""}
 />
 `;
 }
@@ -1053,6 +1401,45 @@ ${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 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)}" : ""} />
+`;
+}
 //#endregion
 //#region src/embed.ts
 const EMBED_TS = `// Emitted by @contentrain/emitter-astro — the runtime-component client.
@@ -1087,7 +1474,11 @@ export class EmbedError extends Error {
   }
 }
 
-/** Visitor-facing strings — override from the site (\`strings.send = 'Gönder'\`). */
+/**
+ * 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
+ * back to, key for key.
+ */
 export const strings = {
   loading: 'Loading…',
   send: 'Send',
@@ -1573,6 +1964,52 @@ export function resetCaptcha(root: ParentNode): void {
 
 // ─── Mounting (the only DOM code) ───
 
+/** ui-strings dictionary key → the \`strings\` entry it sets. */
+export const STRING_KEYS: ReadonlyArray<readonly [string, keyof typeof strings]> = [
+  ['common.loading', 'loading'],
+  ['common.failed', 'failed'],
+  ['form.send', 'send'],
+  ['form.sending', 'sending'],
+  ['form.honeypot', 'honeypot'],
+  ['comments.title', 'commentsTitle'],
+  ['comments.empty', 'noComments'],
+  ['comments.closed', 'closed'],
+  ['comments.post', 'postComment'],
+  ['comments.reply', 'reply'],
+  ['comments.replying_to', 'replyingTo'],
+  ['comments.cancel', 'cancel'],
+  ['comments.load_more', 'loadMore'],
+  ['comments.moderator', 'moderator'],
+  ['comments.pending', 'pending'],
+  ['comments.posted', 'posted'],
+  ['comments.field.name', 'name'],
+  ['comments.field.email', 'email'],
+  ['comments.field.email_note', 'emailNote'],
+  ['comments.field.website', 'website'],
+  ['comments.field.comment', 'comment'],
+]
+
+/**
+ * Take the page's interface text from the host element. A value that is not a
+ * non-empty string leaves the default; text that cannot be parsed changes
+ * nothing, because a mount that fails over a label is worse than an English one.
+ */
+export function applyStrings(host: HTMLElement): void {
+  const raw = host.dataset.strings
+  if (!raw) return
+  let text: unknown
+  try {
+    text = JSON.parse(raw)
+  } catch {
+    return
+  }
+  if (!text || typeof text !== 'object') return
+  for (const [key, name] of STRING_KEYS) {
+    const value = (text as Record<string, unknown>)[key]
+    if (typeof value === 'string' && value !== '') strings[name] = value
+  }
+}
+
 export function runtimeOf(host: HTMLElement): Runtime {
   return { base_url: host.dataset.baseUrl ?? '', project_id: host.dataset.project ?? '' }
 }
@@ -1606,6 +2043,7 @@ function entriesOf(form: HTMLFormElement): Array<[string, unknown]> {
 
 /** \`<cr-form data-base-url data-project data-model>\` → fetch the config, render, submit. */
 export async function mountForm(host: HTMLElement): Promise<void> {
+  applyStrings(host)
   const rt = runtimeOf(host)
   const model = host.dataset.model ?? ''
   host.innerHTML = '<p class="cr-loading">' + esc(strings.loading) + '</p>'
@@ -1643,6 +2081,7 @@ export async function mountForm(host: HTMLElement): Promise<void> {
 
 /** \`<cr-comments data-base-url data-project data-model data-entry data-locale>\` → thread + form. */
 export async function mountComments(host: HTMLElement): Promise<void> {
+  applyStrings(host)
   const rt = runtimeOf(host)
   const entry = entryOf(host)
   host.innerHTML = '<p class="cr-loading">' + esc(strings.loading) + '</p>'
@@ -1749,6 +2188,110 @@ export async function mountComments(host: HTMLElement): Promise<void> {
 }
 `;
 //#endregion
+//#region src/ui-strings.ts
+/** Where the dictionary lives in an emitted project, relative to its root. */
+const UI_STRINGS_DIR = ".contentrain/content/site/ui-strings";
+/** Every key the runtime components read, with the text they show without a dictionary. */
+const UI_STRING_DEFAULTS = {
+	"comments.cancel": "Cancel",
+	"comments.closed": "Comments are closed.",
+	"comments.empty": "No comments yet.",
+	"comments.field.comment": "Comment",
+	"comments.field.email": "Email",
+	"comments.field.email_note": "(never shown)",
+	"comments.field.name": "Name",
+	"comments.field.website": "Website",
+	"comments.load_more": "Load more comments",
+	"comments.moderator": "Moderator",
+	"comments.noscript": "Comments need JavaScript.",
+	"comments.pending": "Thank you — your comment is awaiting moderation.",
+	"comments.post": "Post comment",
+	"comments.posted": "Your comment has been posted.",
+	"comments.replying_to": "Replying to",
+	"comments.reply": "Reply",
+	"comments.title": "Comments",
+	"common.failed": "Something went wrong. Please try again.",
+	"common.loading": "Loading…",
+	"form.honeypot": "Leave this field empty",
+	"form.noscript": "This form needs JavaScript.",
+	"form.send": "Send",
+	"form.sending": "Sending…"
+};
+/**
+* The dictionary model a producer creates in the site's store. Exported so the
+* migration and the emitter cannot disagree about its id, kind or domain.
+*/
+const UI_STRINGS_MODEL = {
+	id: "ui-strings",
+	name: "Site interface text",
+	kind: "dictionary",
+	domain: "site",
+	i18n: true,
+	title_field: DICTIONARY_TITLE_FIELD,
+	description: "What the site’s comments and forms say to visitors, per language. Missing keys fall back to English."
+};
+/**
+* A project-relative directory safe to put in a glob, or undefined. The value
+* lands in source the build evaluates, so anything that could leave the
+* project or change the pattern is refused rather than escaped.
+*/
+function uiStringsDir(dir) {
+	const value = (dir ?? ".contentrain/content/site/ui-strings").replace(/^\/+|\/+$/g, "");
+	if (!value || value.split("/").some((s) => s === ".." || s === "." || s === "") || !/^[\w.@-]+(?:\/[\w.@-]+)*$/.test(value)) return void 0;
+	return value;
+}
+/**
+* `src/lib/ui-strings.ts` for an emitted project: reads every locale file of
+* the dictionary at build time and resolves a page's text over the defaults.
+*
+* `import.meta.glob` returns an empty map when nothing matches, so a project
+* without the dictionary still builds. It does not stay quiet about it: a page
+* in a language other than English with no dictionary, or a dictionary missing
+* keys, is reported once in the build log.
+*/
+function uiStringsSource(dir) {
+	const pattern = `/${dir}/*.json`;
+	return `// Emitted by @contentrain/emitter-astro — the site's interface text.
+//
+// Comments and forms read their visitor-facing text from the ui-strings
+// dictionary in the content store (${dir}/{locale}.json), so it is
+// edited as content — in Studio or through MCP — and a rebuild applies it.
+// Keys the dictionary does not have show the English default below.
+
+const DEFAULTS: Record<string, string> = ${JSON.stringify(UI_STRING_DEFAULTS, null, 2)}
+
+const files = import.meta.glob<Record<string, unknown>>(${JSON.stringify(pattern)}, { eager: true, import: 'default' })
+const dictionaries = new Map(
+  Object.entries(files).map(([path, dictionary]) => [path.slice(path.lastIndexOf('/') + 1, -5).toLowerCase(), dictionary]),
+)
+const reported = new Set<string>()
+
+/** The interface text for a page language: the dictionary's values over the defaults. */
+export function uiStrings(lang: string | undefined): Record<string, string> {
+  const locale = (lang || 'en').toLowerCase()
+  // tr-TR reads tr.json when there is no tr-tr.json — the store keys by primary subtag.
+  const name = dictionaries.has(locale) ? locale : (locale.split('-')[0] ?? locale)
+  const dictionary = dictionaries.get(name)
+  const text: Record<string, string> = { ...DEFAULTS }
+  const missing: string[] = []
+  for (const key of Object.keys(DEFAULTS)) {
+    const value = dictionary?.[key]
+    if (typeof value === 'string' && value !== '') text[key] = value
+    else missing.push(key)
+  }
+  if (!name.startsWith('en') && missing.length && !reported.has(name)) {
+    reported.add(name)
+    console.warn(
+      dictionary
+        ? '[contentrain] ui-strings: ' + name + '.json has no text for ' + missing.join(', ') + ' — those show in English'
+        : '[contentrain] ui-strings: no dictionary for "' + name + '" at ${dir}/' + name + '.json — comments and forms show English text',
+    )
+  }
+  return text
+}
+`;
+}
+//#endregion
 //#region src/components.ts
 /** Component types this emitter implements against a runtime binding. */
 const RUNTIME_IMPLEMENTED = new Set(["comments", "form"]);
@@ -1756,7 +2299,7 @@ function isRuntimeImplemented(c, runtime) {
 	if (!runtime || c.source !== "runtime" || !RUNTIME_IMPLEMENTED.has(c.type)) return false;
 	return c.type !== "form" || Boolean(c.model);
 }
-function componentFiles(components, runtime, queryBound = /* @__PURE__ */ new Set()) {
+function componentFiles(components, runtime, queryBound = /* @__PURE__ */ new Set(), uiStringsDir = ".contentrain/content/site/ui-strings") {
 	const files = {};
 	const warnings = [];
 	let needsRuntime = false;
@@ -1776,6 +2319,7 @@ function componentFiles(components, runtime, queryBound = /* @__PURE__ */ new Se
 			project_id: runtime.project_id
 		});
 		files["src/lib/embed.ts"] = EMBED_TS;
+		files["src/lib/ui-strings.ts"] = uiStringsSource(uiStringsDir);
 	}
 	return {
 		files,
@@ -1803,6 +2347,8 @@ interface Props {
    * while staying current there.
    */
   html?: string
+  /** The page's language; unused by a placeholder. */
+  lang?: string
 }
 const { variant = ${JSON.stringify(variants[0] ?? "default")}, html } = Astro.props
 ---
@@ -1819,13 +2365,19 @@ ${header(c, `
  * moderation happens on the provider. Renders nothing on a page without an
  * entry address (a list, a static page).`)}
 import runtime from '../data/runtime.json'
+import { uiStrings } from '../lib/ui-strings'
 
 interface Props {
   /** Content-store address of the page's entry — the thread's key. */
   entry?: { model_id: string; entry_id: string; locale?: string }
   variant?: string
+  /** Accepted for uniform mounting — the layout passes it to every mount; a thread renders its own markup. */
+  html?: string
+  /** The page's language — which ui-strings dictionary the thread's text comes from. */
+  lang?: string
 }
-const { entry, variant = 'default' } = Astro.props
+const { entry, variant = 'default', lang } = Astro.props
+const text = uiStrings(lang)
 ---
 {entry && (
   <cr-comments
@@ -1836,8 +2388,9 @@ const { entry, variant = 'default' } = Astro.props
     data-entry={entry.entry_id}
     data-locale={entry.locale}
     data-variant={variant}
+    data-strings={JSON.stringify(text)}
   >
-    <noscript><p class="cr-noscript">Comments need JavaScript.</p></noscript>
+    <noscript><p class="cr-noscript">{text['comments.noscript']}</p></noscript>
   </cr-comments>
 )}
 
@@ -1862,13 +2415,19 @@ ${header(c, `
  * Submissions land on the provider for moderation; an approved one becomes a
  * content entry there.`)}
 import runtime from '../data/runtime.json'
+import { uiStrings } from '../lib/ui-strings'
 
 interface Props {
   variant?: string
   /** Accepted for uniform mounting; a form is addressed by its model, not by the page's entry. */
   entry?: { model_id: string; entry_id: string; locale?: string }
+  /** Accepted for uniform mounting — the layout passes it to every mount; a form renders its own markup. */
+  html?: string
+  /** The page's language — which ui-strings dictionary the form's text comes from. */
+  lang?: string
 }
-const { variant = 'default' } = Astro.props
+const { variant = 'default', lang } = Astro.props
+const text = uiStrings(lang)
 ---
 <cr-form
   class={\`cr-form-mount cr-form-mount--\${variant}\`}
@@ -1876,8 +2435,9 @@ const { variant = 'default' } = Astro.props
   data-project={runtime.project_id}
   data-model=${JSON.stringify(c.model)}
   data-variant={variant}
+  data-strings={JSON.stringify(text)}
 >
-  <noscript><p class="cr-noscript">This form needs JavaScript.</p></noscript>
+  <noscript><p class="cr-noscript">{text['form.noscript']}</p></noscript>
 </cr-form>
 
 <script>
@@ -1964,6 +2524,134 @@ function chromeComponents(families) {
 	};
 }
 //#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/css.ts
 const LEADING = /^(\s*(?:@charset[^;]+;|@import[^;]+;|\/\*[\s\S]*?\*\/)\s*)+/;
 function wrapLegacyCss(path, css) {
@@ -1976,6 +2664,13 @@ function wrapLegacyCss(path, css) {
 }
 //#endregion
 //#region src/index.ts
+/**
+* A supplied trail the build will not print — the same rule as \`validTrail\`
+* in the emitted runtime, which a test holds this to.
+*/
+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)));
+}
 function emitAstroProject(input) {
 	const { ir } = input;
 	const warnings = [];
@@ -1995,6 +2690,7 @@ function emitAstroProject(input) {
 		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");
 	}
+	if (input.options?.sitemap !== false && !ir.site.url) warnings.push("site.url is empty — no sitemap is generated and robots.txt names none; set it so search engines can find every page");
 	const familiesById = new Map(ir.families.map((f) => [f.id, f]));
 	const lang = ir.site.locales?.[0] ?? "en";
 	const chrome = chromeComponents(ir.families);
@@ -2019,6 +2715,7 @@ function emitAstroProject(input) {
 			continue;
 		}
 		if (pages.length !== 1) warnings.push(`family ${family.id}: placement "${placement.component}" binds query "${placement.query}", which has ${pages.length} result sets — a page region has no route parameter to choose between them, so the build stops rather than rendering one of them everywhere`);
+		else if (!pages[0].item_template && !pages[0].sections?.length) warnings.push(`family ${family.id}: placement "${placement.component}" binds query "${placement.query}", which has no item_template or sections — plain fallback list rendered (not fidelity)`);
 		add({ [`src/data/queries/${placement.query}.json`]: stableJson(pages) });
 		boundQueries.add(placement.query);
 		queryBound.add(placement.component);
@@ -2045,10 +2742,37 @@ function emitAstroProject(input) {
 	const allPosts = [...input.content?.posts ?? [], ...Object.values(input.content?.collections ?? {}).flat()];
 	for (const post of allPosts) missingCss(post.css, `post ${post.slug}`);
 	for (const [queryId, queryPages] of Object.entries(input.content?.queries ?? {})) for (const qp of queryPages) missingCss(qp.css, `query ${queryId}`);
+	const trailOwners = [...Object.entries(input.content?.collections ?? {}), ...input.content?.posts ? [[DEFAULT_COLLECTION, input.content.posts]] : []];
+	for (const [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`);
+	}
+	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`);
+	}
+	let routeContent = input.content ?? {};
+	if (seo) {
+		const alternates = withAlternates(ir.routes, routeContent, lang);
+		routeContent = alternates.content;
+		warnings.push(...alternates.warnings);
+	}
+	const routeGroups = /* @__PURE__ */ new Map();
+	for (const route of ir.routes) {
+		const path = patternToPagePath(route.pattern);
+		if (path) routeGroups.set(path, [...routeGroups.get(path) ?? [], route]);
+	}
+	const sharedPages = /* @__PURE__ */ new Map();
+	for (const [path, group] of routeGroups) {
+		if (!group.every((route) => familiesById.has(route.family))) continue;
+		const page = sharedCollectionPage(group, routeContent, lang, seo);
+		if (page) sharedPages.set(`src/pages/${path}`, page);
+	}
 	const pageOwner = /* @__PURE__ */ new Map();
 	const collisions = [];
 	for (const route of ir.routes) {
-		const result = routeFiles(route, familiesById.get(route.family), input.content ?? {}, lang, seo);
+		const result = routeFiles(route, familiesById.get(route.family), routeContent, lang, seo);
+		for (const path of sharedPages.keys()) delete result.files[path];
 		for (const path of Object.keys(result.files)) {
 			if (!path.startsWith("src/pages/")) continue;
 			const owner = pageOwner.get(path);
@@ -2065,13 +2789,22 @@ function emitAstroProject(input) {
 		add(result.files);
 		warnings.push(...result.warnings);
 	}
+	for (const [path, page] of sharedPages) files[path] = page;
 	for (const { path, first, second } of collisions) {
 		warnings.push(`route ${second.id}: pattern "${second.pattern}" emits the same Astro page as route ${first.id} ("${first.pattern}") — ${path}. Every page of "${second.id}" would be dropped, so the page now fails the build instead. Give one route a distinct pattern, or expand the narrower one into literal routes.`);
 		files[path] = collisionPage(path, first, second);
 	}
-	const components = componentFiles(ir.components ?? [], input.runtime, queryBound);
+	const stringsDir = uiStringsDir(input.options?.uiStrings?.dir);
+	if (stringsDir === void 0) warnings.push(`options.uiStrings.dir "${input.options?.uiStrings?.dir}" is not a project-relative directory — using ${UI_STRINGS_DIR}`);
+	const components = componentFiles(ir.components ?? [], input.runtime, queryBound, stringsDir ?? ".contentrain/content/site/ui-strings");
 	add(components.files);
 	warnings.push(...components.warnings);
+	if (components.files["src/lib/ui-strings.ts"]) {
+		const pageLangs = [...new Set([lang, ...ir.routes.map((r) => r.locale).filter((l) => Boolean(l))])].filter((l) => !l.toLowerCase().startsWith("en"));
+		const declared = input.options?.uiStrings?.locales;
+		const uncovered = declared ? pageLangs.filter((l) => !declared.includes(l) && !declared.includes(l.split("-")[0])) : pageLangs;
+		if (uncovered.length) warnings.push(`ui-strings: no dictionary ${declared ? "declared" : "declared in options.uiStrings.locales"} for ${uncovered.join(", ")} — comments and forms on those pages show English text unless ${stringsDir ?? ".contentrain/content/site/ui-strings"}/{locale}.json exists at build`);
+	}
 	if ((ir.components ?? []).some((c) => isRuntimeImplemented(c, input.runtime) && c.type === "comments")) {
 		const collections = { ...input.content?.collections };
 		if (input.content?.posts && !collections["posts"]) collections[DEFAULT_COLLECTION] = input.content.posts;
@@ -2105,6 +2838,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, balanceWarning, bodySeoLeaks, checkBalance, componentMarkers, emitAstroProject, isRuntimeImplemented, pascalCase, patternToPagePath, stableJson, stripSeoTags, wrapLegacyCss, writeEmit };
+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 };
 
 //# sourceMappingURL=index.mjs.map