pagegraph 0.8.4 → 0.10.0

package/dist/content-DbyJoRpj.js

@@ -0,0 +1,1384 @@
+//#region src/core/projections.ts
+const escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+/**
+* A node belongs in the sitemap when it declares a positive sitemap policy, is not
+* a redirect, is not robots-noindexed, and is not a param template (a route whose
+* path still contains a `$` segment — those exist only so their instances inherit).
+*/
+function isSitemapEligible(node) {
+	if (node.policy.redirectTo !== void 0) return false;
+	if (node.policy.robots?.includes("noindex")) return false;
+	if (!node.policy.sitemap) return false;
+	if (node.path.includes("$")) return false;
+	return true;
+}
+/** Canonical absolute URL for a node under the given origin. */
+function urlForNode(origin, node) {
+	return node.path === "/" ? origin : `${origin}${node.path}`;
+}
+/**
+* The date a node's content last changed, as declared: an instance's
+* `modifiedAt`, else its `publishedAt`; a route's own `modifiedAt`. A node with
+* no date (a docs page without frontmatter dates, an undated route) returns
+* undefined, and the sitemap omits its `<lastmod>`.
+*/
+function lastModified(node) {
+	if (node.instance) return node.instance.modifiedAt ?? node.instance.publishedAt;
+	return node.policy.modifiedAt;
+}
+/** An ISO 8601 date, or a date-time that states its offset. */
+const ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2}))?$/;
+/**
+* Parse a declared date to epoch milliseconds, or undefined when it is not an
+* ISO 8601 date (`2026-09-29`) or offset date-time (`2026-09-29T10:00:00Z`) on a
+* real calendar day. `Date.parse` alone would accept "Sep 29" in the host's
+* zone and roll "2026-02-30" into March; either would publish a wrong
+* `<lastmod>`. The `invalid-date` check reports the undefined case, so
+* projections that meet one fail loudly.
+*/
+function parseDeclaredDate(value) {
+	const match = ISO_DATE.exec(value);
+	if (match === null) return void 0;
+	const [year, month, day] = [
+		Number(match[1]),
+		Number(match[2]),
+		Number(match[3])
+	];
+	const calendar = new Date(Date.UTC(year, month - 1, day));
+	if (calendar.getUTCMonth() !== month - 1 || calendar.getUTCDate() !== day) return void 0;
+	const time = Date.parse(value);
+	return Number.isNaN(time) ? void 0 : time;
+}
+function sitemapLastmod(node) {
+	const date = lastModified(node);
+	if (date === void 0) return void 0;
+	const time = parseDeclaredDate(date);
+	if (time === void 0) throw new Error(`"${node.path}" declares an invalid date "${date}"; run \`pagegraph check\`.`);
+	return new Date(time).toISOString();
+}
+function renderUrlEntry(url, lastmod, node) {
+	const { changeFrequency, priority } = node.policy.sitemap;
+	const lines = [`  <url>`, `    <loc>${escapeXml(url)}</loc>`];
+	if (lastmod) lines.push(`    <lastmod>${lastmod}</lastmod>`);
+	lines.push(`    <changefreq>${changeFrequency}</changefreq>`, `    <priority>${priority.toFixed(1)}</priority>`, `  </url>`);
+	return lines.join("\n");
+}
+/**
+* Render sitemap.xml from the graph. Each entry's `<lastmod>` is its
+* {@link lastModified} date: frontmatter for content instances, the declared
+* `modifiedAt` for routes. Route entries are sorted by path, then instances follow in collection order.
+* `indexable` is intentionally unused — the sitemap body is host-independent;
+* robots.txt is what gates crawling.
+*/
+function renderSitemap(graph, cfg) {
+	const nodes = [...graph.nodes.values()];
+	const staticNodes = nodes.filter((node) => node.source === "route" && isSitemapEligible(node)).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+	const instanceNodes = nodes.filter((node) => node.source !== "route" && isSitemapEligible(node));
+	const seen = /* @__PURE__ */ new Set();
+	const entries = [];
+	for (const node of [...staticNodes, ...instanceNodes]) {
+		const url = urlForNode(cfg.origin, node);
+		const key = url.toLowerCase().replace(/\/$/, "");
+		if (seen.has(key)) continue;
+		seen.add(key);
+		entries.push(renderUrlEntry(url, sitemapLastmod(node), node));
+	}
+	return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${entries.join("\n")}\n</urlset>\n`;
+}
+/** Format a Content-Signal robots.txt directive from the preference list. */
+function contentSignal(value) {
+	return `Content-Signal: ${value}`;
+}
+const groupLines = (cfg) => {
+	const lines = [];
+	if (cfg.contentSignal !== void 0 && cfg.contentSignal !== "") lines.push(contentSignal(cfg.contentSignal));
+	for (const directive of cfg.directives ?? []) if (directive !== "") lines.push(directive);
+	return lines;
+};
+/**
+* Render robots.txt. A non-indexable host (previews) gets a disallow-all
+* with no Sitemap line; an indexable host disallows exactly the prefixes the caller
+* passes. Pages that declare `robots: noindex` are intentionally NOT added as
+* Disallow entries — a Disallow would stop crawlers reaching the page to read its
+* `noindex, follow` meta, so the graph's per-node robots policy never feeds this
+* list. `graph` is unused — kept for signature parity with the other projections,
+* which callers load the graph once for and pass to each.
+*
+* Origin-wide group directives (`contentSignal`, `directives`) are indexable-host
+* only. {@link RobotsConfig.transform} always runs last so a consumer can override
+* the whole file.
+*/
+function renderRobots(_graph, cfg) {
+	const rendered = cfg.indexable ? [
+		"User-agent: *",
+		...groupLines(cfg),
+		"Allow: /",
+		...cfg.disallow.map((path) => `Disallow: ${path}`),
+		"",
+		`Sitemap: ${cfg.origin}/sitemap.xml`,
+		`Host: ${cfg.origin}`,
+		""
+	].join("\n") : [
+		"User-agent: *",
+		"Disallow: /",
+		""
+	].join("\n");
+	return cfg.transform === void 0 ? rendered : cfg.transform(rendered);
+}
+/** Inspect a single node: its declaration, sitemap eligibility, and edges. */
+function inspectNode(graph, path) {
+	const node = graph.nodes.get(path);
+	if (!node) return void 0;
+	return {
+		node,
+		inSitemap: isSitemapEligible(node),
+		incoming: graph.edges.filter((edge) => edge.to === path),
+		outgoing: graph.edges.filter((edge) => edge.from === path)
+	};
+}
+//#endregion
+//#region src/core/freshness.ts
+const DAY_MS = 864e5;
+/**
+* Split the graph's sitemap-eligible pages into stale, fresh, undated, and
+* invalid. An invalid date cannot be aged, but it is listed so a report never
+* reads as complete while it skipped a page.
+*/
+function freshnessReport(graph, policy, now) {
+	const stale = [];
+	const fresh = [];
+	const undated = [];
+	const invalid = [];
+	for (const node of graph.nodes.values()) {
+		if (!isSitemapEligible(node)) continue;
+		const declared = lastModified(node);
+		if (declared === void 0) {
+			undated.push(node.path);
+			continue;
+		}
+		const time = parseDeclaredDate(declared);
+		if (time === void 0) {
+			invalid.push(node.path);
+			continue;
+		}
+		const entry = {
+			path: node.path,
+			kind: node.kind,
+			source: node.source,
+			lastModified: new Date(time).toISOString(),
+			ageDays: Math.max(0, Math.floor((now.getTime() - time) / DAY_MS))
+		};
+		(entry.ageDays > policy.maxAgeDays ? stale : fresh).push(entry);
+	}
+	stale.sort((a, b) => b.ageDays - a.ageDays || (a.path < b.path ? -1 : 1));
+	fresh.sort((a, b) => a.ageDays - b.ageDays || (a.path < b.path ? -1 : 1));
+	return {
+		asOf: now.toISOString(),
+		maxAgeDays: policy.maxAgeDays,
+		stale,
+		fresh,
+		undated,
+		invalid
+	};
+}
+//#endregion
+//#region src/core/checks.ts
+/** A positive sitemap policy — the author asked for this page to be indexed. */
+const hasPositiveSitemap = (sitemap) => sitemap !== void 0 && sitemap !== false;
+/** Content and manifest instances carry page-level title/description. */
+const isInstance = (node) => node.source !== "route";
+/** Group instance nodes by a present, non-empty string field for duplicate detection. */
+const groupInstancesBy = (graph, field) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes.values()) {
+		if (!isInstance(node)) continue;
+		const value = field(node)?.trim();
+		if (!value) continue;
+		const bucket = groups.get(value);
+		if (bucket) bucket.push(node);
+		else groups.set(value, [node]);
+	}
+	return groups;
+};
+const DESCRIPTION_MAX = 160;
+const DESCRIPTION_MIN = 50;
+/**
+* Every check, in one place. `checkGraph` runs them in order and stamps each
+* finding with its rule name and severity, so the output is grouped by rule and
+* deterministic (nodes iterate in graph insertion order, edges in array order).
+*/
+const CHECK_RULES = [
+	{
+		name: "path-owner-collision",
+		severity: "structural",
+		evaluate: (graph) => (graph.collisions ?? []).map((collision) => ({
+			path: collision.path,
+			message: `Canonical path "${collision.path}" is owned by multiple sources: ${collision.sources.join(", ")}.`,
+			fix: "Give every concrete page one canonical path and one graph owner."
+		}))
+	},
+	{
+		name: "canonical-path-collision",
+		severity: "structural",
+		evaluate: (graph) => {
+			const groups = /* @__PURE__ */ new Map();
+			for (const path of graph.nodes.keys()) {
+				const canonical = path.toLowerCase().replace(/\/$/, "") || "/";
+				const paths = groups.get(canonical);
+				if (paths) paths.push(path);
+				else groups.set(canonical, [path]);
+			}
+			return [...groups.values()].filter((paths) => paths.length > 1).flatMap((paths) => paths.map((path) => ({
+				path,
+				message: `Canonical path collides with ${paths.filter((candidate) => candidate !== path).join(", ")}.`,
+				fix: "Use one lowercase, trailing-slash-normalized canonical path."
+			})));
+		}
+	},
+	{
+		name: "self-edge",
+		severity: "structural",
+		evaluate: (graph) => graph.edges.filter((edge) => edge.from === edge.to).map((edge) => ({
+			path: edge.from,
+			message: `${edge.type} edge points back to its own source node.`,
+			fix: "Remove the self-reference from the canonical manifest or route declaration."
+		}))
+	},
+	{
+		name: "duplicate-edge",
+		severity: "structural",
+		evaluate: (graph) => {
+			const seen = /* @__PURE__ */ new Set();
+			const duplicates = [];
+			for (const edge of graph.edges) {
+				const key = `${edge.from}\u0000${edge.to}\u0000${edge.type}`;
+				if (seen.has(key)) duplicates.push({
+					path: edge.from,
+					message: `Duplicate ${edge.type} edge from "${edge.from}" to "${edge.to}".`,
+					fix: "Declare each graph relationship exactly once."
+				});
+				else seen.add(key);
+			}
+			return duplicates;
+		}
+	},
+	{
+		name: "dead-edge",
+		severity: "structural",
+		evaluate: (graph) => graph.edges.filter((edge) => edge.type !== "crumb-parent" && !graph.nodes.has(edge.to)).map((edge) => ({
+			path: edge.from,
+			message: `${edge.type} edge from "${edge.from}" points at "${edge.to}", which is not a node in the graph.`,
+			fix: `Update the ${edge.type === "redirect" ? "redirectTo" : "related"} target on the "${edge.from}" route, or restore "${edge.to}".`
+		}))
+	},
+	{
+		name: "instance-missing-title",
+		severity: "structural",
+		evaluate: (graph) => [...graph.nodes.values()].filter((node) => isInstance(node) && !node.instance?.title.trim()).map((node) => ({
+			path: node.path,
+			message: `Content page "${node.path}" has no title.`,
+			fix: "Add a `title` to the page frontmatter."
+		}))
+	},
+	{
+		name: "sitemap-noindex-contradiction",
+		severity: "structural",
+		evaluate: (graph) => [...graph.nodes.values()].filter((node) => hasPositiveSitemap(node.policy.sitemap) && node.policy.robots?.toLowerCase().includes("noindex")).map((node) => ({
+			path: node.path,
+			message: `"${node.path}" declares a sitemap policy but its robots value is "${node.policy.robots}".`,
+			fix: "Drop the sitemap policy (or set `sitemap: false`) on a noindex page, or remove the noindex robots value."
+		}))
+	},
+	{
+		name: "robots-not-lowercase",
+		severity: "structural",
+		evaluate: (graph) => [...graph.nodes.values()].filter((node) => node.policy.robots !== void 0 && node.policy.robots !== node.policy.robots.toLowerCase()).map((node) => ({
+			path: node.path,
+			message: `"${node.path}" declares robots "${node.policy.robots}" — robots values must be lowercase.`,
+			fix: "Lowercase the robots declaration (e.g. \"noindex, follow\")."
+		}))
+	},
+	{
+		name: "related-target-missing-link",
+		severity: "structural",
+		evaluate: (graph) => {
+			const linklessTargets = /* @__PURE__ */ new Set();
+			for (const edge of graph.edges) {
+				if (edge.type !== "related") continue;
+				const target = graph.nodes.get(edge.to);
+				if (target && target.source === "route" && target.policy.link === void 0) linklessTargets.add(edge.to);
+			}
+			return [...linklessTargets].map((path) => ({
+				path,
+				message: `Route "${path}" is a related-link target but declares no link metadata; its card would render empty.`,
+				fix: `Add \`link: { title, description }\` to the "${path}" route's staticData.seo.`
+			}));
+		}
+	},
+	{
+		name: "redirect-in-sitemap",
+		severity: "structural",
+		evaluate: (graph) => [...graph.nodes.values()].filter((node) => node.policy.redirectTo !== void 0 && hasPositiveSitemap(node.policy.sitemap)).map((node) => ({
+			path: node.path,
+			message: `Redirect "${node.path}" (→ "${node.policy.redirectTo}") also declares a sitemap policy.`,
+			fix: "Remove the sitemap policy from the redirect route; only its target belongs in the sitemap."
+		}))
+	},
+	{
+		name: "invalid-date",
+		severity: "structural",
+		evaluate: (graph) => [...graph.nodes.values()].flatMap((node) => {
+			return (node.instance ? [["publishedAt", node.instance.publishedAt], ["modifiedAt", node.instance.modifiedAt]] : [["modifiedAt", node.policy.modifiedAt]]).flatMap(([field, value]) => value !== void 0 && parseDeclaredDate(value) === void 0 ? [{
+				path: node.path,
+				message: `${field} "${value}" is not an ISO 8601 date on a real calendar day.`,
+				fix: `Write ${field} as an ISO 8601 date, e.g. "2026-09-29".`
+			}] : []);
+		})
+	},
+	{
+		name: "duplicate-title",
+		severity: "editorial",
+		evaluate: (graph) => [...groupInstancesBy(graph, (node) => node.instance?.title).entries()].filter(([, nodes]) => nodes.length > 1).flatMap(([title, nodes]) => nodes.map((node) => ({
+			path: node.path,
+			message: `Title "${title}" is shared by ${nodes.length} pages.`,
+			fix: "Give each page a distinct title."
+		})))
+	},
+	{
+		name: "duplicate-description",
+		severity: "editorial",
+		evaluate: (graph) => [...groupInstancesBy(graph, (node) => node.instance?.description).entries()].filter(([, nodes]) => nodes.length > 1).flatMap(([, nodes]) => nodes.map((node) => ({
+			path: node.path,
+			message: `Description is shared by ${nodes.length} pages.`,
+			fix: "Write a distinct meta description for each page."
+		})))
+	},
+	{
+		name: "description-length",
+		severity: "editorial",
+		evaluate: (graph) => [...graph.nodes.values()].flatMap((node) => {
+			if (!isInstance(node)) return [];
+			const description = node.instance?.description?.trim();
+			if (!description) return [];
+			if (description.length > DESCRIPTION_MAX) return [{
+				path: node.path,
+				message: `Description is ${description.length} chars (max ${DESCRIPTION_MAX}); it will be truncated in results.`,
+				fix: `Trim the description to ${DESCRIPTION_MAX} characters or fewer.`
+			}];
+			if (description.length < DESCRIPTION_MIN) return [{
+				path: node.path,
+				message: `Description is ${description.length} chars (min ${DESCRIPTION_MIN}); it reads as thin.`,
+				fix: `Expand the description to at least ${DESCRIPTION_MIN} characters.`
+			}];
+			return [];
+		})
+	}
+];
+/**
+* Run every static rule against the graph, then any caller-supplied
+* {@link CoverageRule}s and freshness policy, and return the flat list of
+* violations. With no options the result is exactly the static rule set.
+*/
+function checkGraph(graph, options = {}) {
+	const violations = CHECK_RULES.flatMap((rule) => rule.evaluate(graph).map((raw) => ({
+		severity: rule.severity,
+		rule: rule.name,
+		path: raw.path,
+		message: raw.message,
+		fix: raw.fix
+	})));
+	const coverage = options.coverage;
+	if (coverage !== void 0 && coverage.length > 0) violations.push(...checkCoverage(graph, coverage));
+	if (options.freshness !== void 0) violations.push(...checkFreshness(graph, options.freshness, options.now));
+	return violations;
+}
+/**
+* One editorial `stale-page` violation per sitemap-eligible page whose last
+* declared change is older than the policy allows. Undated pages are not
+* violations: see {@link freshnessReport} for the full picture.
+*/
+function checkFreshness(graph, policy, now) {
+	return freshnessReport(graph, policy, now).stale.map((entry) => ({
+		severity: "editorial",
+		rule: "stale-page",
+		path: entry.path,
+		message: `Last changed ${entry.lastModified.slice(0, 10)}, ${entry.ageDays} days ago (limit ${policy.maxAgeDays}).`,
+		fix: "Review the page; when its content changes, update its modifiedAt."
+	}));
+}
+/** Escape a glob for `RegExp`, then expand `**`, `*`, and `?` to path-aware forms. */
+const globToRegExp = (glob) => {
+	const source = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\u0000/g, ".*");
+	return new RegExp(`^${source}$`);
+};
+/**
+* Enforce contextual-link coverage rules over an explicit surface.
+*
+* A rule that matches no sitemap-eligible page is itself a violation: a typo or
+* a rule aimed at a noindex page would otherwise pass silently forever.
+*/
+const checkCoverageRules = (surface, rules) => {
+	const violations = [];
+	for (const rule of rules) {
+		const matcher = globToRegExp(rule.path);
+		const matched = surface.paths.filter((path) => matcher.test(path));
+		const eligible = surface.eligiblePaths.filter((path) => matcher.test(path));
+		if (eligible.length === 0) {
+			violations.push({
+				severity: "structural",
+				rule: "coverage-rule-unmatched",
+				message: matched.length === 0 ? `Coverage rule "${rule.path}" matches no page in the graph.` : `Coverage rule "${rule.path}" matches only pages that are not sitemap-eligible.`,
+				fix: "Point the rule at a sitemap-eligible path, or drop it."
+			});
+			continue;
+		}
+		for (const path of eligible) {
+			const inbound = surface.inbound(path);
+			if (inbound >= rule.minInbound) continue;
+			violations.push({
+				severity: "structural",
+				rule: "inbound-link-coverage",
+				path,
+				message: `"${path}" has ${inbound} incoming contextual link(s); the coverage rule requires ${rule.minInbound}.`,
+				fix: `Add ${rule.minInbound - inbound} contextual link(s) pointing at "${path}".`
+			});
+		}
+	}
+	return violations;
+};
+/** The sitemap-eligible path set of a declared graph, in graph insertion order. */
+const eligiblePathsOf = (graph) => [...graph.nodes.values()].filter(isSitemapEligible).map((node) => node.path);
+/**
+* Enforce contextual-link coverage against the *declared* graph: only `related`
+* edges count — breadcrumb ancestry is navigation, not context.
+*/
+function checkCoverage(graph, rules) {
+	return checkCoverageRules({
+		paths: [...graph.nodes.keys()],
+		eligiblePaths: eligiblePathsOf(graph),
+		inbound: (path) => graph.edges.filter((edge) => edge.type === "related" && edge.to === path).length
+	}, rules);
+}
+/**
+* Enforce contextual-link coverage against the *rendered* graph: only same-origin
+* body-region anchors count. Nav, header, and footer anchors are site chrome, so
+* a page linked solely from them has no contextual inbound link — the same
+* distinction the declared pass draws by counting `related` edges alone.
+*
+* The target universe is the declared graph's sitemap-eligible pages: the globs
+* in `seo.config.ts` are written against declared paths, and the crawl is what
+* supplies the served edges. Pass the crawl's `internalEdges` (each edge carries
+* its `region`).
+*/
+function checkRenderedCoverage(graph, renderedEdges, rules) {
+	const inbound = /* @__PURE__ */ new Map();
+	for (const edge of renderedEdges) {
+		if (edge.region !== "body") continue;
+		inbound.set(edge.to, (inbound.get(edge.to) ?? 0) + 1);
+	}
+	return checkCoverageRules({
+		paths: [...graph.nodes.keys()],
+		eligiblePaths: eligiblePathsOf(graph),
+		inbound: (path) => inbound.get(path) ?? 0
+	}, rules);
+}
+/** Structural violations fail `pagegraph check`; editorial-only stays green. */
+const hasStructuralViolations = (violations) => violations.some((violation) => violation.severity === "structural");
+//#endregion
+//#region src/core/inspect-html.ts
+const ENTITIES = {
+	"&amp;": "&",
+	"&lt;": "<",
+	"&gt;": ">",
+	"&quot;": "\"",
+	"&#39;": "'",
+	"&apos;": "'"
+};
+const decodeEntities$2 = (value) => value.replace(/&(?:amp|lt|gt|quot|#39|apos);/g, (match) => ENTITIES[match] ?? match);
+/** Pull double/single-quoted attributes off a single tag string. */
+const parseAttrs = (tag) => {
+	const attrs = {};
+	const re = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+	let match;
+	while ((match = re.exec(tag)) !== null) attrs[match[1].toLowerCase()] = decodeEntities$2(match[2] ?? match[3] ?? "");
+	return attrs;
+};
+/** Normalize a JSON-LD `@type` (string or array) to a single readable label. */
+const typeName = (value) => {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.filter((v) => typeof v === "string").join(", ") || "unknown";
+	return "unknown";
+};
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Flatten a parsed JSON-LD payload (single object, array, or `@graph`) to items. */
+const collectItems = (parsed) => {
+	if (Array.isArray(parsed)) return parsed.filter(isObject);
+	if (isObject(parsed)) {
+		if (Array.isArray(parsed["@graph"])) return parsed["@graph"].filter(isObject);
+		return [parsed];
+	}
+	return [];
+};
+const countQuestions = (mainEntity) => {
+	if (!Array.isArray(mainEntity)) return 0;
+	return mainEntity.filter((entry) => isObject(entry) && typeName(entry["@type"]) === "Question").length;
+};
+const validateItemListElements = (value) => {
+	if (!Array.isArray(value) || value.length < 1) return ["ItemList needs at least one `itemListElement` entry."];
+	const errors = [];
+	value.forEach((entry, index) => {
+		if (!isObject(entry) || typeName(entry["@type"]) !== "ListItem") {
+			errors.push(`ItemList entry ${index + 1} is not a ListItem.`);
+			return;
+		}
+		if (entry["position"] !== index + 1) errors.push(`ItemList entry ${index + 1} has an invalid position.`);
+		if (!entry["name"] || !entry["url"]) errors.push(`ItemList entry ${index + 1} needs a name and URL.`);
+	});
+	return errors;
+};
+/** Minimal per-type validation — enough to catch an empty or malformed block. */
+const validateItem = (item) => {
+	const type = typeName(item["@type"]);
+	const errors = [];
+	if (type === "Article" || type === "NewsArticle" || type === "BlogPosting") {
+		if (!item["headline"]) errors.push("Article is missing `headline`.");
+		if (!item["datePublished"]) errors.push("Article is missing `datePublished`.");
+	} else if (type === "FAQPage") {
+		if (countQuestions(item["mainEntity"]) < 1) errors.push("FAQPage needs at least one Question in `mainEntity`.");
+	} else if (type === "BreadcrumbList") {
+		const items = item["itemListElement"];
+		if (!Array.isArray(items) || items.length < 2) errors.push("BreadcrumbList needs at least two `itemListElement` entries.");
+	} else if (type === "ItemList") {
+		errors.push(...validateItemListElements(item["itemListElement"]));
+		const items = item["itemListElement"];
+		if (Array.isArray(items) && item["numberOfItems"] !== items.length) errors.push("ItemList `numberOfItems` does not match its entries.");
+	}
+	return {
+		type,
+		valid: errors.length === 0,
+		errors
+	};
+};
+const validateLdJson = (raw) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (cause) {
+		return [{
+			type: "unparseable",
+			valid: false,
+			errors: [`JSON parse error: ${cause instanceof Error ? cause.message : String(cause)}`]
+		}];
+	}
+	const items = collectItems(parsed);
+	if (items.length === 0) return [{
+		type: "unknown",
+		valid: false,
+		errors: ["No JSON-LD object found in block."]
+	}];
+	return items.map(validateItem);
+};
+/** Parse a rendered HTML document's `<head>` into a report. Pure. */
+const inspectHtml = (url, status, html) => {
+	const headMatch = html.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
+	const head = headMatch ? headMatch[1] : html;
+	const titleMatch = head.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+	const title = titleMatch ? decodeEntities$2(titleMatch[1].trim()) : void 0;
+	const og = {};
+	const twitter = {};
+	let description;
+	let robots;
+	for (const tag of head.match(/<meta\b[^>]*>/gi) ?? []) {
+		const attrs = parseAttrs(tag);
+		const content = attrs["content"];
+		if (content === void 0) continue;
+		const property = attrs["property"];
+		const name = attrs["name"];
+		if (property?.startsWith("og:")) og[property] = content;
+		else if (name?.startsWith("twitter:")) twitter[name] = content;
+		else if (name === "description") description = content;
+		else if (name === "robots") robots = content;
+	}
+	let canonical;
+	for (const tag of head.match(/<link\b[^>]*>/gi) ?? []) {
+		const attrs = parseAttrs(tag);
+		if (attrs["rel"] === "canonical") canonical = attrs["href"];
+	}
+	const jsonLd = [];
+	const scriptRe = /<script\b[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+	let scriptMatch;
+	while ((scriptMatch = scriptRe.exec(head)) !== null) jsonLd.push(...validateLdJson(scriptMatch[1].trim()));
+	const issues = [];
+	if (status >= 400) issues.push(`Fetch returned HTTP ${status}.`);
+	if (!title) issues.push("Missing <title>.");
+	if (!description) issues.push("Missing meta description.");
+	if (!canonical) issues.push("Missing canonical link.");
+	for (const block of jsonLd) if (!block.valid) issues.push(...block.errors.map((error) => `JSON-LD (${block.type}): ${error}`));
+	return {
+		url,
+		status,
+		title,
+		description,
+		canonical,
+		robots,
+		og,
+		twitter,
+		jsonLd,
+		issues
+	};
+};
+/** A non-empty `issues` list fails `pagegraph inspect --live` (exit 1). */
+const hasBlockingIssues = (report) => report.issues.length > 0;
+//#endregion
+//#region src/core/links.ts
+const TOKEN = /<(\/?)(nav|footer|header)\b[^>]*>|<a\b([^>]*)>([\s\S]*?)<\/a>/gi;
+const HREF = /(?:^|\s)href\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i;
+const BASE_TAG = /<base\b[^>]*>/gi;
+const NON_NAVIGABLE = /^(?:#|mailto:|tel:|javascript:|data:)/i;
+const stripTags = (value) => value.replace(/<[^>]*>/g, " ");
+const decodeEntities$1 = (value) => value.replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, "\"").replace(/&#39;|&apos;/gi, "'");
+const anchorText = (value) => decodeEntities$1(stripTags(value)).replace(/\s+/g, " ").trim();
+/** Normalize a same-origin URL to the graph's path key (no query/hash; "/" preserved). */
+const normalizePath = (url) => {
+	const path = url.pathname.replace(/\/+$/, "");
+	return path === "" ? "/" : path;
+};
+const hrefValue = (attributes) => {
+	const match = HREF.exec(attributes);
+	if (match === null) return void 0;
+	return match[1] ?? match[2] ?? match[3];
+};
+/**
+* The document base URL. Browsers use the first `<base>` element that has an
+* `href` attribute and ignore every later one, so a `<base>` carrying only
+* `target` is skipped, but the first `<base href>` wins even when its value is
+* empty (it then resolves to the document URL) or invalid (the base is ignored,
+* resolving to the document URL). With no `<base href>` at all, links resolve
+* against the response URL.
+*/
+const documentBase = (html, responseUrl) => {
+	BASE_TAG.lastIndex = 0;
+	let tag;
+	while ((tag = BASE_TAG.exec(html)) !== null) {
+		const href = hrefValue(tag[0]);
+		if (href === void 0) continue;
+		if (href.length === 0) return responseUrl;
+		try {
+			return new URL(href, responseUrl);
+		} catch {
+			return responseUrl;
+		}
+	}
+	return responseUrl;
+};
+/**
+* Extract every anchor in document order, tagging each with the region tag it
+* sits inside. Anchor text keeps only its letters and a coarse entity decode;
+* this is a classifier input, not a renderer.
+*/
+const extractAnchors = (html, baseUrl) => {
+	const base = new URL(baseUrl);
+	const resolutionBase = documentBase(html, base);
+	const regions = [];
+	const anchors = [];
+	TOKEN.lastIndex = 0;
+	let match;
+	while ((match = TOKEN.exec(html)) !== null) {
+		const closing = match[1];
+		const regionTag = match[2];
+		if (regionTag !== void 0) {
+			const region = regionTag.toLowerCase();
+			if (closing === "/") {
+				const index = regions.lastIndexOf(region);
+				if (index !== -1) regions.splice(index, 1);
+			} else regions.push(region);
+			continue;
+		}
+		const attributes = match[3];
+		const raw = hrefValue(attributes);
+		if (raw === void 0 || raw.length === 0 || NON_NAVIGABLE.test(raw)) continue;
+		let resolved;
+		try {
+			resolved = new URL(raw, resolutionBase);
+		} catch {
+			continue;
+		}
+		if (resolved.protocol !== "http:" && resolved.protocol !== "https:") continue;
+		const region = regions.length === 0 ? "body" : regions[regions.length - 1];
+		anchors.push({
+			href: resolved.href,
+			text: anchorText(match[4] ?? ""),
+			region,
+			internal: resolved.origin === base.origin
+		});
+	}
+	return anchors;
+};
+const breadthFirstDepth = (edges, root) => {
+	const adjacency = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		const targets = adjacency.get(edge.from) ?? /* @__PURE__ */ new Set();
+		targets.add(edge.to);
+		adjacency.set(edge.from, targets);
+	}
+	const depth = /* @__PURE__ */ new Map([[root, 0]]);
+	const queue = [root];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		const currentDepth = depth.get(current);
+		for (const next of adjacency.get(current) ?? []) {
+			if (depth.has(next)) continue;
+			depth.set(next, currentDepth + 1);
+			queue.push(next);
+		}
+	}
+	return depth;
+};
+/**
+* Assemble a {@link RenderedGraph} from page/edge sets. Edges are already
+* same-origin and path-keyed by the callers, so this is the shared, pure tail of
+* {@link buildRenderedGraph} and {@link renderedGraphFromEdges}.
+*/
+const graphFromEdges = (nodes, edges, root) => {
+	const rootKey = root.replace(/\/+$/, "") || "/";
+	const internalEdges = edges;
+	const contextualEdges = edges.filter((edge) => edge.region === "body");
+	const incoming = new Set(internalEdges.map((edge) => edge.to));
+	const orphans = [...nodes].filter((path) => path !== rootKey && !incoming.has(path)).sort();
+	const depthByPath = breadthFirstDepth(internalEdges, rootKey);
+	let maxDepth = null;
+	for (const value of depthByPath.values()) if (maxDepth === null || value > maxDepth) maxDepth = value;
+	return {
+		nodes: [...nodes],
+		edges,
+		internalEdges,
+		contextualEdges,
+		orphans,
+		depthByPath,
+		maxDepth
+	};
+};
+/**
+* Build the rendered graph from crawled pages. `origin` fixes the graph's
+* same-origin boundary — pages and anchors on another origin are dropped, not
+* silently folded in — and `root` is the normalized path the depth BFS starts
+* from (the seed's final path when the homepage redirected). Every page path is
+* keyed the way the declared graph keys its routes.
+*/
+const buildRenderedGraph = (origin, pages, root = "/") => {
+	const graphOrigin = new URL(origin).origin;
+	const edges = [];
+	const nodes = /* @__PURE__ */ new Set();
+	for (const page of pages) {
+		let pageUrl;
+		try {
+			pageUrl = new URL(page.url);
+		} catch {
+			continue;
+		}
+		if (pageUrl.origin !== graphOrigin) continue;
+		const path = normalizePath(pageUrl);
+		nodes.add(path);
+		for (const anchor of page.anchors) {
+			let targetUrl;
+			try {
+				targetUrl = new URL(anchor.href);
+			} catch {
+				continue;
+			}
+			if (targetUrl.origin !== graphOrigin) continue;
+			const target = normalizePath(targetUrl);
+			if (target === path) continue;
+			edges.push({
+				from: path,
+				to: target,
+				region: anchor.region
+			});
+		}
+	}
+	return graphFromEdges(nodes, edges, root);
+};
+/** A URL or an already-normalized graph path key both collapse to the path key. */
+const pathKeyOf = (value) => {
+	try {
+		return normalizePath(new URL(value));
+	} catch {
+		return (value.split(/[?#]/, 1)[0] ?? "").replace(/\/+$/, "") || "/";
+	}
+};
+/**
+* Rebuild a {@link RenderedGraph} from a rendered-edge set alone — the artifact
+* `pagegraph links verify --emit-rendered` writes. Path keys are normalized the
+* same way as a crawl, and `nodes` carries the rendered page paths the artifact
+* recorded, so an edge-less page (a redirect target with no internal links) stays
+* a node and its orphan/depth report survives replay. Without `nodes` the node set
+* falls back to the edge endpoints.
+*/
+const renderedGraphFromEdges = (edges, root = "/", nodes = []) => {
+	const nodeSet = new Set(nodes.map(pathKeyOf));
+	const kept = [];
+	for (const edge of edges) {
+		const from = pathKeyOf(edge.from);
+		const to = pathKeyOf(edge.to);
+		nodeSet.add(from);
+		nodeSet.add(to);
+		kept.push({
+			from,
+			to,
+			region: edge.region
+		});
+	}
+	return graphFromEdges(nodeSet, kept, root);
+};
+const edgeKey = (edge) => `${edge.from}\u0000${edge.to}`;
+const normalizeEdge = (edge) => ({
+	from: edge.from === "" ? "/" : edge.from.replace(/\/+$/, "") || "/",
+	to: edge.to === "" ? "/" : edge.to.replace(/\/+$/, "") || "/"
+});
+/**
+* Diff rendered contextual edges against declared `related`/`crumb` edges. Both
+* sides are path-keyed; the diff is directional and reports each direction
+* separately because they call for different fixes.
+*/
+const diffLinkGraph = (declared, rendered) => {
+	const declaredNormalized = declared.map(normalizeEdge);
+	const declaredKeys = new Set(declaredNormalized.map(edgeKey));
+	const renderedKeys = new Set(rendered.contextualEdges.map(edgeKey));
+	return {
+		declaredNotRendered: declaredNormalized.filter((edge) => !renderedKeys.has(edgeKey(edge))),
+		renderedNotDeclared: rendered.internalEdges.filter((edge) => edge.region === "body").map((edge) => normalizeEdge(edge)).filter((edge) => !declaredKeys.has(edgeKey(edge))),
+		declaredCount: declaredNormalized.length,
+		renderedContextualCount: rendered.contextualEdges.length
+	};
+};
+/** The rendered-edge artifact schema this package writes and accepts. */
+const RENDERED_EDGE_ARTIFACT_SCHEMA_VERSION = 1;
+const ARTIFACT_KIND = "links-rendered";
+const REGIONS = /* @__PURE__ */ new Set([
+	"nav",
+	"footer",
+	"header",
+	"body"
+]);
+const decodeArtifactEdges = (input) => {
+	if (!Array.isArray(input)) throw new Error("`edges` must be an array of { from, to, region } edges");
+	return input.map((item) => {
+		if (item === null || typeof item !== "object") throw new Error("each artifact edge must be an object with string `from` and `to`");
+		const { from, to, region } = item;
+		if (typeof from !== "string" || typeof to !== "string") throw new Error("each artifact edge must have string `from` and `to`");
+		if (region !== void 0 && !REGIONS.has(region)) throw new Error(`artifact edge region must be one of nav, footer, header, body (received ${JSON.stringify(region)})`);
+		return {
+			from,
+			to,
+			region: region ?? "body"
+		};
+	});
+};
+const decodeArtifactNodes = (input) => {
+	if (input === void 0) return [];
+	if (!Array.isArray(input) || !input.every((path) => typeof path === "string")) throw new Error("rendered-edge artifact `nodes` must be an array of paths");
+	return input;
+};
+const decodeArtifactFailures = (input) => {
+	if (input === void 0) return [];
+	if (!Array.isArray(input)) throw new Error("rendered-edge artifact `crawl.failures` must be an array");
+	return input.map((item) => {
+		if (item === null || typeof item !== "object") throw new Error("each artifact failure must be an object with string `url` and `error`");
+		const { url, error } = item;
+		if (typeof url !== "string" || typeof error !== "string") throw new Error("each artifact failure must have string `url` and `error`");
+		return {
+			url,
+			error
+		};
+	});
+};
+const requiredAbsoluteUrl = (value, field) => {
+	if (typeof value !== "string" || value === "") throw new Error(`rendered-edge artifact must carry a non-empty string \`${field}\``);
+	try {
+		new URL(value);
+	} catch {
+		throw new Error(`rendered-edge artifact \`${field}\` must be an absolute URL (received ${JSON.stringify(value)})`);
+	}
+	return value;
+};
+const requiredInteger = (value, field, minimum) => {
+	if (!Number.isSafeInteger(value) || value < minimum) throw new Error(`rendered-edge artifact \`${field}\` must be an integer >= ${minimum} (received ${JSON.stringify(value)})`);
+	return value;
+};
+/**
+* Decode a rendered-edge artifact from user input. Throws on any other shape —
+* this is user input, not a provider payload. `root`, `bodyTruncated`,
+* `truncatedPages`, `failures`, and `nodes` are optional so a hand-written edge
+* dump that only carries provenance can still be replayed.
+*/
+const decodeRenderedEdgeArtifact = (input) => {
+	if (input === null || typeof input !== "object") throw new Error("rendered-edge artifact must be an object");
+	const value = input;
+	if (value["kind"] !== ARTIFACT_KIND) throw new Error(`rendered-edge artifact \`kind\` must be "${ARTIFACT_KIND}" (received ${JSON.stringify(value["kind"])})`);
+	if (value["schemaVersion"] !== 1) throw new Error(`unsupported rendered-edge artifact schemaVersion: ${JSON.stringify(value["schemaVersion"])}`);
+	const origin = requiredAbsoluteUrl(value["origin"], "origin");
+	const seed = requiredAbsoluteUrl(value["seed"], "seed");
+	const crawl = value["crawl"];
+	if (crawl === null || typeof crawl !== "object") throw new Error("rendered-edge artifact must carry a `crawl` object");
+	const provenance = crawl;
+	const truncatedPages = provenance["truncatedPages"];
+	if (truncatedPages !== void 0 && (!Array.isArray(truncatedPages) || !truncatedPages.every((url) => typeof url === "string"))) throw new Error("rendered-edge artifact `truncatedPages` must be an array of URLs");
+	const bodyTruncated = provenance["bodyTruncated"];
+	if (bodyTruncated !== void 0 && typeof bodyTruncated !== "boolean") throw new Error("rendered-edge artifact `bodyTruncated` must be a boolean");
+	if (typeof provenance["truncated"] !== "boolean") throw new Error("rendered-edge artifact `crawl.truncated` must be a boolean");
+	const skipped = provenance["skipped"];
+	if (skipped !== void 0 && (!Array.isArray(skipped) || !skipped.every((url) => typeof url === "string"))) throw new Error("rendered-edge artifact `crawl.skipped` must be an array of URLs");
+	const nonHtml = provenance["nonHtml"];
+	if (nonHtml !== void 0 && (!Array.isArray(nonHtml) || !nonHtml.every((item) => item !== null && typeof item === "object" && typeof item.url === "string" && typeof item.finalUrl === "string" && typeof item.contentType === "string"))) throw new Error("rendered-edge artifact `crawl.nonHtml` must be an array of { url, finalUrl, contentType }");
+	if (Array.isArray(nonHtml)) for (const item of nonHtml) {
+		requiredAbsoluteUrl(item.url, "crawl.nonHtml.url");
+		requiredAbsoluteUrl(item.finalUrl, "crawl.nonHtml.finalUrl");
+	}
+	for (const field of ["sitemapTruncated", "sitemapUsed"]) if (provenance[field] !== void 0 && typeof provenance[field] !== "boolean") throw new Error(`rendered-edge artifact \`crawl.${field}\` must be a boolean`);
+	return {
+		kind: ARTIFACT_KIND,
+		schemaVersion: 1,
+		origin,
+		seed,
+		crawl: {
+			pages: requiredInteger(provenance["pages"], "crawl.pages", 0),
+			root: typeof provenance["root"] === "string" ? provenance["root"] : pathKeyOf(seed),
+			limit: requiredInteger(provenance["limit"], "crawl.limit", 1),
+			truncated: provenance["truncated"],
+			bodyTruncated: bodyTruncated === true,
+			truncatedPages: truncatedPages ?? [],
+			failures: decodeArtifactFailures(provenance["failures"]),
+			...nonHtml === void 0 ? {} : { nonHtml },
+			...provenance["discoveryFailures"] === void 0 ? {} : { discoveryFailures: decodeArtifactFailures(provenance["discoveryFailures"]) },
+			...skipped === void 0 ? {} : { skipped },
+			...provenance["sitemapTruncated"] === void 0 ? {} : { sitemapTruncated: provenance["sitemapTruncated"] },
+			...provenance["sitemapUsed"] === void 0 ? {} : { sitemapUsed: provenance["sitemapUsed"] }
+		},
+		nodes: decodeArtifactNodes(value["nodes"]),
+		edges: decodeArtifactEdges(value["edges"])
+	};
+};
+//#endregion
+//#region src/core/content.ts
+const NAMED_ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: " ",
+	ndash: "–",
+	mdash: "—",
+	lsquo: "‘",
+	rsquo: "’",
+	ldquo: "“",
+	rdquo: "”",
+	hellip: "…",
+	middot: "·",
+	bull: "•",
+	copy: "©",
+	reg: "®",
+	trade: "™",
+	times: "×",
+	euro: "€",
+	pound: "£"
+};
+const decodeEntities = (value) => value.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (entity, code) => {
+	if (code.startsWith("#")) {
+		const point = code[1] === "x" || code[1] === "X" ? Number.parseInt(code.slice(2), 16) : Number.parseInt(code.slice(1), 10);
+		return Number.isInteger(point) && point > 0 && point <= 1114111 ? String.fromCodePoint(point) : entity;
+	}
+	return NAMED_ENTITIES[code.toLowerCase()] ?? entity;
+});
+/** Elements whose contents a reader never sees as page text. */
+const INVISIBLE = /<(script|style|template|noscript|svg)\b[\s\S]*?<\/\1\s*>/gi;
+const COMMENT = /<!--[\s\S]*?-->/g;
+const withoutInvisible = (html) => html.replace(COMMENT, " ").replace(INVISIBLE, " ");
+const textOf = (html) => decodeEntities(html.replace(/<[^>]*>/g, " ")).replace(/\s+/g, " ").trim();
+const attributeOf = (tag, name) => {
+	const match = new RegExp(`(?:^|\\s)${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, "i").exec(tag);
+	const value = match?.[1] ?? match?.[2] ?? match?.[3];
+	return value === void 0 ? void 0 : decodeEntities(value);
+};
+const bodyOf = (html) => {
+	const body = /<body\b[^>]*>([\s\S]*)<\/body>/i.exec(html);
+	if (body) return body[1];
+	return html.replace(/<head\b[^>]*>[\s\S]*?<\/head>/i, " ");
+};
+/**
+* The main content region: `<main>` when the page has one, otherwise the body
+* without its `<nav>` and `<footer>` blocks. Site chrome repeats on every page,
+* so counting its headings or words would judge the layout, not the page.
+*/
+const mainRegionOf = (body) => {
+	const main = /<main\b[^>]*>([\s\S]*?)<\/main\s*>/i.exec(body);
+	if (main) return main[1];
+	return body.replace(/<(nav|footer)\b[\s\S]*?<\/\1\s*>/gi, " ");
+};
+const HEADING = /<h([1-6])\b([^>]*)>([\s\S]*?)<\/h\1\s*>/gi;
+/**
+* A heading's accessible text: its content, else its `aria-label`, else the
+* `alt` of images inside it (a logo H1).
+*/
+const headingText = (attributes, inner) => {
+	const text = textOf(inner);
+	if (text !== "") return text;
+	const label = attributeOf(attributes, "aria-label")?.trim();
+	if (label) return label;
+	return [...inner.matchAll(/<img\b[^>]*>/gi)].map((image) => attributeOf(image[0], "alt")?.trim() ?? "").filter(Boolean).join(" ");
+};
+const headingsOf = (html) => [...html.matchAll(HEADING)].map((match) => ({
+	level: Number(match[1]),
+	text: headingText(match[2], match[3])
+}));
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Every object with an `@type`, at any depth — offers nest in products, questions in FAQ pages. */
+const collectTyped = (value, into) => {
+	if (Array.isArray(value)) {
+		for (const entry of value) collectTyped(entry, into);
+		return;
+	}
+	if (!isRecord(value)) return;
+	if (value["@type"] !== void 0) into.push(value);
+	for (const child of Object.values(value)) collectTyped(child, into);
+};
+const JSON_LD = /<script\b[^>]*type\s*=\s*["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script\s*>/gi;
+/** Parse every JSON-LD block. A block that does not parse is `inspectHtml`'s finding, not ours. */
+const jsonLdOf = (html) => {
+	const nodes = [];
+	for (const match of html.matchAll(JSON_LD)) {
+		let parsed;
+		try {
+			parsed = JSON.parse(match[1].trim());
+		} catch {
+			continue;
+		}
+		collectTyped(parsed, nodes);
+	}
+	return nodes;
+};
+/**
+* Text normalized for "does this appear on the page" comparisons: Unicode-folded,
+* lowercased, and reduced to runs of letters and digits. Punctuation, quotes,
+* dashes, and markup spacing differ freely between JSON-LD and rendered copy
+* without changing what a reader sees.
+*/
+const matchText = (value) => value.normalize("NFKC").toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean).join(" ");
+const countWords = (text) => {
+	const normalized = matchText(text);
+	return normalized === "" ? 0 : normalized.split(" ").length;
+};
+/** Reduce a rendered HTML document to the fields the content rules read. Pure. */
+const extractPageContent = (html) => {
+	const head = inspectHtml("", 200, html);
+	const body = withoutInvisible(bodyOf(html));
+	const main = mainRegionOf(body);
+	return {
+		title: head.title,
+		description: head.description,
+		robots: head.robots,
+		canonical: head.canonical,
+		h1: headingsOf(body).filter((heading) => heading.level === 1).map((heading) => heading.text),
+		outline: headingsOf(main),
+		wordCount: countWords(textOf(main)),
+		text: textOf(body),
+		jsonLd: jsonLdOf(html)
+	};
+};
+const typesOf = (node) => {
+	const type = node["@type"];
+	if (typeof type === "string") return [type];
+	if (Array.isArray(type)) return type.filter((entry) => typeof entry === "string");
+	return [];
+};
+const hasType = (node, types) => typesOf(node).some((type) => types.has(type));
+const stringField = (node, field) => {
+	const value = node[field];
+	return typeof value === "string" && value.trim() !== "" ? value : void 0;
+};
+/** JSON-LD text may carry the HTML Google allows in answers; compare its text. */
+const jsonLdText = (value) => textOf(value);
+const isVisible = (visible, candidate) => {
+	const needle = matchText(jsonLdText(candidate));
+	return needle === "" || ` ${visible} `.includes(` ${needle} `);
+};
+const clip = (value, max = 80) => value.length > max ? `${value.slice(0, max - 1)}…` : value;
+const STOPWORDS = new Set("a an and are as at be but by can for from get has have how in into is it its more not of on or our per than that the their this to use via vs was what when who why will with you your".split(" "));
+/**
+* Terms that carry meaning, reduced to a crude stem: stopwords drop, a plural
+* `s` folds, and long words compare by their first six letters, so
+* "Authentication" and "Authenticate" or "templates" and "template" agree. The
+* rule only asks whether any term is shared, so a lenient stem errs toward
+* silence, never toward a false warning.
+*/
+const significantTerms = (value) => new Set(matchText(value).split(" ").filter((term) => term !== "" && !STOPWORDS.has(term) && (term.length > 2 || /\d/.test(term))).map((term) => term.length > 3 && term.endsWith("s") ? term.slice(0, -1) : term).map((term) => term.slice(0, 6)));
+/** schema.org `WebPage` and the subtypes whose `name`/`description` describe the page itself. */
+const WEB_PAGE_TYPES = /* @__PURE__ */ new Set([
+	"WebPage",
+	"AboutPage",
+	"CheckoutPage",
+	"CollectionPage",
+	"ContactPage",
+	"FAQPage",
+	"ItemPage",
+	"MedicalWebPage",
+	"ProfilePage",
+	"QAPage",
+	"RealEstateListing",
+	"SearchResultsPage"
+]);
+const OFFER_TYPES = /* @__PURE__ */ new Set(["Offer", "AggregateOffer"]);
+const FAQ_TYPES = /* @__PURE__ */ new Set(["FAQPage"]);
+const asArray = (value) => value === void 0 ? [] : Array.isArray(value) ? value : [value];
+/** Parse a schema.org price (`19`, `"19.00"`, `"1,000"`); undefined when it is not a number. */
+const parsePrice = (value) => {
+	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+	if (typeof value !== "string") return void 0;
+	const cleaned = value.replace(/[^\d.]/g, "");
+	if (cleaned === "" || !/^\d*\.?\d+$/.test(cleaned)) return void 0;
+	return Number(cleaned);
+};
+const pricesOf = (offer) => [
+	offer["price"],
+	offer["lowPrice"],
+	offer["highPrice"],
+	...asArray(offer["priceSpecification"]).flatMap((spec) => isRecord(spec) ? [
+		spec["price"],
+		spec["minPrice"],
+		spec["maxPrice"]
+	] : [])
+].flatMap((value) => {
+	const price = parsePrice(value);
+	return price === void 0 ? [] : [price];
+});
+/**
+* Whether a price appears as a number in the visible text: `19` matches `$19`,
+* `19.00`, and `19/mo`; `1000` matches `1,000`; `0.5` matches `0.50`. A price of
+* zero also matches the word "free".
+*/
+const priceIsVisible = (price, text) => {
+	if (price === 0 && /\bfree\b/i.test(text)) return true;
+	const [whole, fraction = ""] = String(price).split(".");
+	const grouped = whole.replace(/\B(?=(\d{3})+(?!\d))/g, "[,.\\u00a0 ]?");
+	const decimals = fraction === "" ? "(?:[.,]0+)?" : `[.,]${fraction}0*`;
+	return new RegExp(`(?<![\\d.,])${grouped}${decimals}(?![\\d]|[.,]\\d)`).test(text);
+};
+/**
+* Whether a JSON-LD `name` agrees with the rendered `<title>`. A title usually
+* wraps the page name in a site-name affix ("Pricing | Example"), so either
+* containing the other counts as agreement.
+*/
+const namesAgree = (a, b) => {
+	const left = matchText(a);
+	const right = matchText(b);
+	if (left === "" || right === "") return true;
+	return ` ${left} `.includes(` ${right} `) || ` ${right} `.includes(` ${left} `);
+};
+/**
+* Every content rule, in one place. Heading-count and structured-data rules that
+* Google treats as eligibility or policy problems are structural; outline and
+* wording smells are editorial.
+*/
+const CONTENT_RULES = [
+	{
+		name: "missing-h1",
+		severity: "structural",
+		evaluate: (content) => content.h1.length === 0 ? [{
+			message: "Page has no H1.",
+			fix: "Render exactly one <h1> that names the page's topic."
+		}] : []
+	},
+	{
+		name: "multiple-h1",
+		severity: "structural",
+		evaluate: (content) => content.h1.length > 1 ? [{
+			message: `Page has ${content.h1.length} H1s: ${content.h1.map((text) => `"${clip(text, 40)}"`).join(", ")}.`,
+			fix: "Keep one <h1> for the page topic; demote the others to <h2>."
+		}] : []
+	},
+	{
+		name: "empty-h1",
+		severity: "structural",
+		evaluate: (content) => content.h1.some((text) => text === "") ? [{
+			message: "An H1 has no text, aria-label, or image alt.",
+			fix: "Give the <h1> visible text that names the page's topic."
+		}] : []
+	},
+	{
+		name: "heading-level-skip",
+		severity: "editorial",
+		evaluate: (content) => {
+			const skips = [];
+			let previous = 1;
+			for (const heading of content.outline) {
+				if (heading.level > previous + 1) skips.push(`h${previous} → h${heading.level} "${clip(heading.text, 40)}"`);
+				previous = heading.level;
+			}
+			return skips.length === 0 ? [] : [{
+				message: `Heading levels skip ${skips.length} time(s): ${skips.slice(0, 3).join("; ")}${skips.length > 3 ? "; …" : ""}.`,
+				fix: "Nest headings one level at a time; style a heading with CSS, not by choosing a deeper level."
+			}];
+		}
+	},
+	{
+		name: "h1-title-mismatch",
+		severity: "editorial",
+		evaluate: (content) => {
+			const [h1] = content.h1;
+			if (content.h1.length !== 1 || !h1 || !content.title) return [];
+			const title = significantTerms(content.title);
+			return [...significantTerms(h1)].some((term) => title.has(term)) ? [] : [{
+				message: `H1 "${clip(h1, 60)}" shares no significant term with the title "${clip(content.title, 60)}".`,
+				fix: "Make the H1 and <title> describe the same topic; a searcher who clicks the title should recognize the page."
+			}];
+		}
+	},
+	{
+		name: "faq-not-visible",
+		severity: "structural",
+		evaluate: (content) => {
+			const visible = matchText(content.text);
+			return content.jsonLd.filter((node) => hasType(node, FAQ_TYPES)).flatMap((faq) => asArray(faq["mainEntity"])).filter(isRecord).flatMap((question) => {
+				const name = stringField(question, "name");
+				const answers = asArray(question["acceptedAnswer"]).filter(isRecord).flatMap((answer) => {
+					const text = stringField(answer, "text");
+					return text === void 0 ? [] : [text];
+				});
+				const missing = [...name !== void 0 && !isVisible(visible, name) ? ["question"] : [], ...answers.some((answer) => !isVisible(visible, answer)) ? ["answer"] : []];
+				return missing.length === 0 ? [] : [{
+					message: `FAQPage ${missing.join(" and ")} for "${clip(name ?? "(unnamed)", 70)}" is not in the rendered page text.`,
+					fix: "Render every FAQ question and answer in the server HTML, or drop the entry from the FAQPage JSON-LD."
+				}];
+			});
+		}
+	},
+	{
+		name: "offer-price-not-visible",
+		severity: "structural",
+		evaluate: (content) => content.jsonLd.filter((node) => hasType(node, OFFER_TYPES)).flatMap((offer) => {
+			const hidden = pricesOf(offer).filter((price) => !priceIsVisible(price, content.text));
+			if (hidden.length === 0) return [];
+			const currency = stringField(offer, "priceCurrency");
+			return [{
+				message: `${stringField(offer, "name") ?? typesOf(offer).join(", ")} price ${hidden.map((price) => `${price}${currency ? ` ${currency}` : ""}`).join(", ")} does not appear in the rendered page text.`,
+				fix: "Show the offer's price in the server-rendered copy, or correct the JSON-LD price."
+			}];
+		})
+	},
+	{
+		name: "webpage-head-mismatch",
+		severity: "editorial",
+		evaluate: (content) => content.jsonLd.filter((node) => hasType(node, WEB_PAGE_TYPES)).flatMap((page) => {
+			const findings = [];
+			const name = stringField(page, "name");
+			if (name !== void 0 && content.title && !namesAgree(name, content.title)) findings.push({
+				message: `${typesOf(page).join(", ")} name "${clip(name, 60)}" does not match the title "${clip(content.title, 60)}".`,
+				fix: "Derive the JSON-LD name from the same value as the <title>."
+			});
+			const description = stringField(page, "description");
+			if (description !== void 0 && content.description && matchText(description) !== matchText(content.description)) findings.push({
+				message: `${typesOf(page).join(", ")} description differs from the meta description.`,
+				fix: "Derive the JSON-LD description from the same value as the meta description."
+			});
+			return findings;
+		})
+	},
+	{
+		name: "thin-content",
+		severity: "editorial",
+		evaluate: (content, options) => options.minWords !== void 0 && content.wordCount < options.minWords ? [{
+			message: `Main content has ${content.wordCount} words (min ${options.minWords}).`,
+			fix: "Answer the page's search intent in more depth, or merge it into a stronger page."
+		}] : []
+	}
+];
+/** Run every content rule against one rendered page. Graph-independent; pure. */
+const checkPageContent = (content, options = {}) => CONTENT_RULES.flatMap((rule) => rule.evaluate(content, options).map((raw) => ({
+	rule: rule.name,
+	severity: rule.severity,
+	message: raw.message,
+	fix: raw.fix
+})));
+const declaresNoindex = (node) => node.policy.robots?.toLowerCase().includes("noindex") === true;
+/**
+* The declared pages a rendered check fetches: every sitemap-eligible page,
+* plus concrete pages that declare `noindex` so the rendered robots meta can be
+* held to that declaration. Param templates and redirects render no page of
+* their own.
+*/
+const renderedCheckTargets = (graph) => [...graph.nodes.values()].filter((node) => isSitemapEligible(node) || declaresNoindex(node) && node.policy.redirectTo === void 0 && !node.path.includes("$")).map((node) => node.path);
+const PATH_BASE = "https://pagegraph.invalid";
+/**
+* A path as a URL serializes it (`/café` → `/caf%C3%A9`), trailing slash
+* dropped. Declared paths, response URLs, and canonicals are compared in this
+* one form, or a page with non-ASCII segments would read as redirected.
+*/
+const urlPath = (value) => {
+	try {
+		return normalizePath(new URL(value, PATH_BASE));
+	} catch {
+		return;
+	}
+};
+/**
+* Judge rendered documents against the declared graph. Every indexable page must
+* render, stay on its path, keep a self-referencing canonical and indexable
+* robots meta, and pass {@link checkPageContent}; a page that declares `noindex`
+* must render a `noindex` robots meta.
+*
+* Robots are read from the `<meta name="robots">` tag only. An `X-Robots-Tag`
+* header is usually host policy (preview hosts noindex everything), so holding
+* pages to it would fail every local run for a reason no declaration controls.
+*/
+function checkRenderedContent(graph, documents, policy = {}) {
+	const violations = [];
+	const push = (rule, severity, path, message, fix) => {
+		violations.push({
+			rule,
+			severity,
+			path,
+			message,
+			fix
+		});
+	};
+	const wordRules = (policy.minWords ?? []).map((rule) => ({
+		rule,
+		matcher: globToRegExp(rule.path)
+	}));
+	const eligible = [...graph.nodes.values()].filter(isSitemapEligible).map((node) => node.path);
+	for (const { rule, matcher } of wordRules) if (!eligible.some((path) => matcher.test(path))) violations.push({
+		severity: "structural",
+		rule: "content-rule-unmatched",
+		message: `Word-count rule "${rule.path}" matches no sitemap-eligible page.`,
+		fix: "Point the rule at a sitemap-eligible path, or drop it."
+	});
+	for (const document of documents) {
+		const node = graph.nodes.get(document.path);
+		if (node === void 0) continue;
+		const declaredPath = urlPath(document.path);
+		if (!document.ok) {
+			push("rendered-page-unavailable", "structural", document.path, `Could not read the rendered page: ${document.error}.`, "Serve the declared page with a 2xx HTML response.");
+			continue;
+		}
+		if (urlPath(document.finalPath) !== declaredPath) {
+			push("rendered-page-unavailable", "structural", document.path, `Rendered page redirects to "${document.finalPath}".`, "Declare the redirect with `redirectTo`, or serve the page at its declared path.");
+			continue;
+		}
+		const content = extractPageContent(document.html);
+		const renderedNoindex = content.robots?.toLowerCase().includes("noindex") === true;
+		if (!isSitemapEligible(node)) {
+			if (!renderedNoindex) push("rendered-robots-mismatch", "structural", document.path, `Declared robots "${node.policy.robots}" but the rendered page has ${content.robots ? `robots "${content.robots}"` : "no robots meta"}.`, "Render the declared robots value in the page's <meta name=\"robots\">.");
+			continue;
+		}
+		if (renderedNoindex) push("rendered-robots-mismatch", "structural", document.path, `Page is in the sitemap but renders robots "${content.robots}".`, "Drop the noindex from the rendered head, or declare the page noindex and remove its sitemap policy.");
+		if ((content.canonical === void 0 ? void 0 : urlPath(content.canonical)) !== declaredPath) push("rendered-canonical-mismatch", "structural", document.path, content.canonical === void 0 ? "Rendered page has no canonical link." : `Rendered canonical "${content.canonical}" does not point at "${document.path}".`, "Render a self-referencing canonical for every indexable page.");
+		const floors = wordRules.filter(({ matcher }) => matcher.test(document.path));
+		const minWords = floors.length === 0 ? void 0 : Math.max(...floors.map(({ rule }) => rule.minWords));
+		for (const finding of checkPageContent(content, { minWords })) push(finding.rule, finding.severity, document.path, finding.message, finding.fix);
+	}
+	return violations;
+}
+//#endregion
+export { lastModified as C, isSitemapEligible as S, renderSitemap as T, checkRenderedCoverage as _, RENDERED_EDGE_ARTIFACT_SCHEMA_VERSION as a, contentSignal as b, diffLinkGraph as c, renderedGraphFromEdges as d, hasBlockingIssues as f, checkGraph as g, checkFreshness as h, renderedCheckTargets as i, extractAnchors as l, checkCoverage as m, checkRenderedContent as n, buildRenderedGraph as o, inspectHtml as p, extractPageContent as r, decodeRenderedEdgeArtifact as s, checkPageContent as t, normalizePath as u, hasStructuralViolations as v, renderRobots as w, inspectNode as x, freshnessReport as y };
+
+//# sourceMappingURL=content-DbyJoRpj.js.map