pagegraph 0.10.0 → 0.11.0

package/README.md

@@ -30,7 +30,7 @@ bun add -D lighthouse   # only for `pagegraph audit` performance evidence
 | `pagegraph`        | `buildSeoGraph`, `renderSitemap`, `renderRobots`, `contentSignal`, `checkGraph`, `checkRenderedCoverage`, `decodeRenderedEdgeArtifact`, `inspectHtml` | —                                           |
 | `pagegraph/react`  | `createSeo` → `seoHead`, `Breadcrumbs`, JSON-LD generators                                     | `react`, `@tanstack/react-router`           |
 | `pagegraph/vite`   | `seoRouteConfig` coverage gate                                                                 | `vite`                                      |
-| `pagegraph/config` | `defineSeoConfig`, `viteGraphLoader`                                                           | `vite`                                      |
+| `pagegraph/config` | `defineSeoConfig`, `viteGraphLoader`, `selectPageHeadNodes`, `pageHeads`, `loadPageHeads`                                                           | `vite`                                      |
 | `pagegraph/audit`  | Audit services, scanner protocol, rules, and report schemas                                    | `effect`                                    |
 | `pagegraph` bin                   | CLI over the same graph                                                                        | bundled — runs on Bun                        |
 
@@ -38,10 +38,19 @@ The core and React import graphs have **zero runtime dependencies** — everythi
 peer, and only the entries you import need those peers loaded.
 
 The CLI **bundles PageGraph's Effect and TypeSafe provider runtime**, so it does not depend on the
-app's Effect RC; it runs on [Bun](https://bun.sh) (`bunx pagegraph`). Agentic workflows load the
-OpenCode SDK and its private Effect runtime only when invoked. `vite` stays a peer — graph commands
+app's Effect version; it runs on [Bun](https://bun.sh) (`bunx pagegraph`). Agentic workflows load the
+OpenCode SDK only when invoked. The first workflow installs pinned OpenCode 2.0.22 into
+`~/.cache/pagegraph/opencode-2.0.22-2`, outside the app's dependency tree; subsequent workflows
+reuse the verified cache. This keeps consumer dependency overrides away from OpenCode's declared
+Effect and Drizzle versions. Executor plugins must use OpenCode's Effect version (`4.0.0-rc.112`).
+Bun and network access to npm are required for the first install. The pinned OpenCode client's
+HTTP error handling retains the method, path, status, and response body for diagnostics;
+undeclared error bodies are capped at 16 KiB.
+Discovery-only research gets one continuation to complete provider evidence; if it still cannot,
+`research-failure.json` preserves the transcript and tool results in the requested output directory. `vite` stays a peer — graph commands
 load your app through Vite at runtime — and `lighthouse` is only needed by `pagegraph audit`.
-Importing `pagegraph/audit` programmatically still needs `effect`.
+Importing `pagegraph/audit` programmatically needs `effect@^4.0.0`. The Effect and TypeSafe
+peers remain optional for other library entry points and the bundled CLI.
 
 ### Agent skill
 
@@ -417,6 +426,33 @@ export default defineSeoConfig({
 });
 ```
 
+`viteGraphLoader<Input>(options)` returns a loader whose JSON input is passed to
+its entry export. Existing zero-argument loaders remain valid. The host resolves
+framework-specific route `head()` values into node instances; pagegraph selects
+and validates the resulting plain metadata:
+
+```ts
+import { loadPageHeads, viteGraphLoader } from "pagegraph/config";
+
+const loader = viteGraphLoader<{ exclude: string[] }>({
+  root: import.meta.dirname,
+  entry: "/lib/seo/graph.ts",
+  exportName: "loadHeadGraph",
+});
+const exclude = ["/docs", "/docs/**", "/captured-page"];
+const heads = await loadPageHeads(() => loader({ exclude }), { exclude });
+```
+
+`selectPageHeadNodes(graph, options)` selects nodes before host metadata resolution.
+`pageHeads(graph, options)` returns `{ path, title, description }[]`, requiring
+nonblank titles and descriptions and naming the page on failure. `loadPageHeads`
+always disposes the acquired graph, including when validation fails. Page nodes
+carry a sitemap declaration or an instance; layouts are excluded. By default,
+selection excludes noindex pages, redirects and parameter templates, while retaining
+sitemap-disabled hubs. Set `indexable: false` to include those nonindexable nodes.
+`exclude` accepts exact paths and path globs (`*` within a segment, `**` across
+segments). Docs are ordinary pages; excluding them is caller policy, not a graph kind.
+
 ```bash
 pagegraph check                 # CI gate — exit 1 on structural violations
 pagegraph check --site <url>    # also check every declared page's rendered HTML

package/dist/audit.js

@@ -1,4 +1,4 @@
-import { l as extractAnchors, r as extractPageContent, t as checkPageContent } from "./content-DbyJoRpj.js";
+import { l as extractAnchors, r as extractPageContent, t as checkPageContent } from "./content-CB_kHmJ3.js";
 import { mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import * as Context from "effect/Context";

package/dist/checks-nk8ZRRIA.js

@@ -0,0 +1,490 @@
+//#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
+export { globToRegExp as a, contentSignal as c, lastModified as d, renderRobots as f, checkRenderedCoverage as i, inspectNode as l, checkFreshness as n, hasStructuralViolations as o, renderSitemap as p, checkGraph as r, freshnessReport as s, checkCoverage as t, isSitemapEligible as u };
+
+//# sourceMappingURL=checks-nk8ZRRIA.js.map