pagegraph 0.12.0 → 0.13.0

package/README.md

@@ -26,20 +26,194 @@ bun add pagegraph
 bun add -D lighthouse   # only for `pagegraph audit` performance evidence
 ```
 
+## Authored pages
+
+Keep authored text beside its React layout. `DocumentProvider` records only its page body when
+supplied a collector; ordinary rendering preserves the layout. `Title` assigns a heading to the
+nearest section or item, `Fact` resolves shared values, and `Visual` describes content for the
+markdown document without rendering its children during capture.
+
+```tsx
+import { renderToStaticMarkup } from "react-dom/server";
+import { defineFacts, fact, documentMarkdown } from "pagegraph";
+import {
+  DocumentProvider, T, Title, Section, Fact, createCollector, finishDocument,
+} from "pagegraph/react";
+
+const facts = defineFacts({ attempts: fact.number(8) });
+declare module "pagegraph" {
+  interface Register { facts: typeof facts }
+}
+
+const collector = createCollector({ path: "/email", site: "https://example.com", facts });
+const page = (
+  <DocumentProvider collector={collector}>
+    <Section kind="prose" id="intro">
+      <h1><Title>Email delivery</Title></h1>
+      <p><T>Retry up to <Fact id="attempts" /> times.</T></p>
+    </Section>
+  </DocumentProvider>
+);
+// Your SSR renderer supplies completed HTML, whose markers determine document order.
+const html = renderToStaticMarkup(page);
+const document = finishDocument(collector, {
+  title: "Email delivery", description: "Reliable delivery with retries.",
+}, html);
+const markdown = documentMarkdown(document, "https://example.com");
+```
+
+Use `defineSectionKind` for custom formatting; its markdown writer provides `text`, `heading`,
+and `table`:
+
+```ts
+import { defineSectionKind } from "pagegraph";
+const comparison = defineSectionKind({
+  kind: "comparison",
+  markdown: (section, md) => md.heading(2, section.title)
+    + md.table(section.items.map((item) => item.cells)),
+}); // pass kind={comparison} to Section
+```
+
+`Section.Item.Link` records a card's destination, while `CaptureAnchor` is the
+public anchor boundary for router `createLink` integrations. `ForAgents` and `ForHumans` mark
+audience-specific text; markdown excludes human-only content. `messageText` extracts text or
+inline markdown for head metadata. The root entry also provides `hashDocument`,
+`createMarkdownLock`, and pure `llmsMarkdown`/`llmsSection` string builders.
+
+## Rendered markdown with TanStack Start
+
+Declare rendered pages on the route that owns `DocumentProvider`. Collection instances inherit
+these fields from their parameter route; the parameter template itself is never captured.
+
+```tsx
+import { createFileRoute } from "@tanstack/react-router";
+import { DocumentProvider, Section, T, Title } from "pagegraph/react";
+import { Link } from "pagegraph/tanstack-start/react";
+
+export const Route = createFileRoute("/pricing")({
+  staticData: {
+    seo: { kind: "page", head: { title: "Pricing", description: "Plans for your team." } },
+    markdown: "rendered",
+    llms: "Product",
+  },
+  head: () => ({ meta: [{ title: "Pricing" }, { name: "description", content: "Plans for your team." }] }),
+  component: () => (
+    <DocumentProvider>
+      <Section kind="prose" id="plans">
+        <h1><Title>Plans for your team</Title></h1>
+        <Link to="/"><T>Back home</T></Link>
+      </Section>
+    </DocumentProvider>
+  ),
+});
+```
+
+`markdown: "source"` identifies pages whose Markdown is supplied by the application; pagegraph
+captures only `"rendered"` pages. `llms` sets an optional llms.txt group. Use the capture-aware
+`Link` for authored links: it uses TanStack's ordinary Link outside a capture and records resolved
+anchor destinations during capture. The plugin adds `source=` locations to authored JSX imported
+from `pagegraph/react`. In development, `DocumentProvider` rejects a current route lacking
+`staticData.markdown: "rendered"`.
+
+Configure the plugin and pass its fixed capture page to Start:
+
+```ts
+import { pagegraph } from "pagegraph/tanstack-start";
+
+const graph = pagegraph({
+  origin: "https://preview.example.com", // this deployment's SEO origin
+  collections: "src/collections.ts",
+  markdown: {
+    origin: "https://example.com", // canonical document and twin links
+    serverEntry: "dist/server/index.js", // default; relative to the Vite root
+  },
+  facts: "src/facts.ts", // exports `facts`; evaluated in the pagegraph environment
+});
+
+// In your Vite plugins:
+// tanstackStart({
+//   prerender: { enabled: true, autoStaticPathsDiscovery: false, crawlLinks: false, failOnError: true },
+//   pages: [...graph.prerenderPages],
+// }), graph
+```
+
+For Cloudflare, wire the non-deployed prerender Worker to the compiled Start server. Add this to
+`cloudflare()` alongside the production Worker's configuration:
+
+```ts
+experimental: {
+  prerenderWorker: {
+    config: {
+      name: "app-markdown-prerender",
+      main: "pagegraph/tanstack-start/prerender-worker",
+      compatibility_date: "2026-09-20",
+      compatibility_flags: ["nodejs_compat"],
+      vars: { TSS_PRERENDERING: "true" },
+      assets: { binding: "ASSETS", run_worker_first: true },
+    },
+  },
+},
+```
+
+Call the capture adapter before your normal Start handler, forwarding the same request options:
+
+```ts
+import handler from "@tanstack/react-start/server-entry";
+import { markdownRequest } from "pagegraph/tanstack-start/markdown";
+
+export default {
+  async fetch(request: Request) {
+    return await markdownRequest(request) ?? handler.fetch(request);
+  },
+};
+```
+
+Only dev and the prerender Worker capture documents. `GET` and `HEAD` on
+`/__pagegraph/markdown.json` capture all rendered pages; `/pricing.md` and
+`/pricing.document.json` capture one page in dev. Ordinary requests return `null`. In production,
+private capture paths return 404 and Markdown twins fall through to your static asset server.
+`markdownPagePaths()` exposes the concrete rendered page paths.
+
+After prerender, the plugin writes `dist/client/pricing.md` (`/` becomes `index.md`),
+`.pagegraph/documents/pricing.json`, and `.pagegraph/heads.json`, and removes the emitted private
+capture response. Stale valid documents at their derived paths are pruned; unrelated files are
+preserved. Ignore the private generated documents and heads in Git. Claims replay is reserved for
+a separate integration.
+
+Serve graph-derived llms.txt without rendering pages:
+
+```ts
+import { createFileRoute } from "@tanstack/react-router";
+import { llmsTxt } from "pagegraph/tanstack-start/server";
+
+export const Route = createFileRoute("/llms.txt")({
+  server: { handlers: { GET: llmsTxt({ sections: ["## Docs\n\nRead our documentation."] }) } },
+});
+```
+
+`llmsSection()` returns the generated section for custom composition. It includes rendered twins
+and explicitly grouped pages, using graph titles and descriptions and `markdown.origin`.
+
 ## What runs where
 
-Every entry belongs to one place. Runtime entries are safe in a Worker, an SSR server, or a
-browser; build entries load your app through Vite, parse routes natively, or drive Node I/O.
+Every entry belongs to one place. Runtime entries use portable graph and document code with
+the framework peers listed below; the capture adapter runs on a Start server. Build entries
+load your app through Vite, parse routes natively, or drive Node I/O.
 
 | Entry              | Runs in                       | Exports                                                                                                   | Peers                             |
 | ------------------ | ----------------------------- | --------------------------------------------------------------------------------------------------------- | --------------------------------- |
-| `pagegraph`        | runtime (Worker, SSR, browser) | `buildSeoGraph`, `contentCollection`, `renderSitemap`, `renderRobots`, `pageHeads`, `graphToJson`/`graphFromJson`, checks, `inspectHtml` | —                                 |
-| `pagegraph/react`  | runtime                       | `createSeo` → `seo.head`, `seoHead`, `Breadcrumbs`, JSON-LD generators                                    | `react`, `@tanstack/react-router` |
-| `pagegraph/tanstack-start/server` | runtime (Start server routes) | `robotsTxt`, `sitemapXml`, `seoGraph`, `seoSite`                                           | the `pagegraph()` plugin          |
-| `pagegraph/tanstack-start` | build (`vite.config.ts`, `seo.config.ts`) | `pagegraph()` Vite plugin, `tanstackStartGraph`, `evaluateAppGraph`                        | `vite`, `@tanstack/router-generator` |
+| `pagegraph`        | runtime (Worker, SSR, browser) | `buildSeoGraph`, `contentCollection`, `renderSitemap`, `renderRobots`, `pageHeads`, `graphToJson`/`graphFromJson`, checks, `inspectHtml`, document types, facts, markdown and locks | —                                 |
+| `pagegraph/react`  | runtime                       | `createSeo` → `seo.head`, `seoHead`, `Breadcrumbs`, JSON-LD generators, authored page primitives                                    | `react`, `@tanstack/react-router` |
+| `pagegraph/tanstack-start/server` | runtime (Start server routes) | `robotsTxt`, `sitemapXml`, `llmsTxt`, `llmsSection`, `seoGraph`, `seoSite`                                           | the `pagegraph()` plugin          |
+| `pagegraph/tanstack-start/markdown` | runtime (Start server) | `markdownRequest`, `markdownPagePaths` | `react`, `react-dom`, `@tanstack/react-start`, `@tanstack/react-router` |
+| `pagegraph/tanstack-start/react` | runtime | capture-aware `Link` | `react`, `@tanstack/react-router` |
+| `pagegraph/tanstack-start/prerender-worker` | non-deployed prerender Worker | compiled Start server | the `pagegraph()` plugin |
+| `pagegraph/tanstack-start` | build (`vite.config.ts`, `pagegraph.config.ts`) | `pagegraph()` Vite plugin, `tanstackStartGraph`, `evaluateAppGraph`                        | `vite`, `@tanstack/router-generator`, `effect` |
 | `pagegraph/vite`   | build (`vite.config.ts`)      | `seoRouteConfig` coverage gate                                                                            | `vite`, `@tanstack/router-generator` |
-| `pagegraph/config` | build (`seo.config.ts`, CLI)  | `defineSeoConfig`, `viteGraphLoader`, `loadPageHeads`                                                     | `vite`                            |
+| `pagegraph/config` | build (`pagegraph.config.ts`, CLI)  | `defineSeoConfig`, `viteGraphLoader`, `loadPageHeads`                                                     | `vite`                            |
+| `pagegraph/claims` | build / CLI (Node or Bun) | `claimsInput`, `claimsFamily`, document resolution, committed claims checks | `effect` |
 | `pagegraph/audit`  | build / CLI (Node or Bun)     | Audit services, scanner protocol, rules, and report schemas                                               | `effect`                          |
+| `pagegraph/oxlint` | build (oxlint)               | `pagegraph` plugin: `no-bare-text`, `t-children`                                                        | —                                 |
 | `pagegraph` bin    | CLI (Bun)                     | CLI over the same graph                                                                                   | bundled                           |
 
 Build entries resolve to a stub under the `workerd`, `worker`, and `browser` export conditions.
@@ -195,15 +369,14 @@ import { robotsTxt } from "pagegraph/tanstack-start/server";
 export const Route = createFileRoute("/robots.txt")({ server: { handlers: { GET: robotsTxt } } });
 ```
 
-**5. Gate CI.** The CLI reads the same graph through `seo.config.ts`:
+**5. Gate CI.** The CLI reads the same graph through `pagegraph.config.ts`:
 
 ```ts
-// seo.config.ts
+// pagegraph.config.ts
 import { defineSeoConfig } from "pagegraph/config";
 import { tanstackStartGraph } from "pagegraph/tanstack-start";
 
 export default defineSeoConfig({
-  origin: "https://example.com",
   loadGraph: tanstackStartGraph({ root: import.meta.dirname }),
 });
 ```
@@ -217,7 +390,7 @@ pagegraph check
 `buildSeoGraph({ routeTree, collections })` builds the same graph from any TanStack
 Router tree; render it with `renderSitemap(graph, { origin, indexable })` and
 `renderRobots(graph, { origin, indexable, disallow, contentSignal })`, and point
-`seo.config.ts` at it with `viteGraphLoader` (see [CLI](#cli)).
+`pagegraph.config.ts` at it with `viteGraphLoader` (see [CLI](#cli)).
 
 `renderRobots` does not invent a Content-Signal. Pass `contentSignal` for
 the value (the plugin prefixes `Content-Signal: `), `directives` for extra
@@ -239,7 +412,7 @@ The generated `.pagegraph/opencode` directory contains one `seo` agent and custo
 the plugin own model and Executor authentication. PageGraph does not copy credentials or assume
 fixed provider-tool addresses.
 
-Enable workflows in `seo.config.ts`:
+Enable workflows in `pagegraph.config.ts`:
 
 ```ts
 export default defineSeoConfig({
@@ -406,27 +579,106 @@ It also derives a small config module from the route tree: `robotsExclusions`
 (the plugin adds them to robots.txt; a Router-only app feeds them to `renderRobots`) and
 `reservedSegments` (top-level segments an app must not hand out as tenant/org slugs).
 
+## Claims gate
+
+Declare probability rules against `claimsInput` from the build-only `pagegraph/claims` entry.
+Each rule asks whether the section violates your policy:
+
+```ts
+import { Decision } from "effect/ai";
+import { claimsInput } from "pagegraph/claims";
+import { pagegraph } from "pagegraph/tanstack-start";
+
+const rules = Decision.make({
+  input: claimsInput,
+  decisions: {
+    unsupportedPromise: Decision.probability({
+      instructions: "Does this section promise a capability unsupported by its facts or evidence?",
+    }),
+  },
+});
+
+const graph = pagegraph({
+  origin: "https://example.com",
+  markdown: { origin: "https://example.com" },
+  facts: "src/facts.ts",
+  claims: { rules, model: "typesafe/jev", cutoff: 0.8 },
+});
+```
+
+Pass `graph.prerenderPages` to Start as shown in the rendered Markdown setup. The build persists
+captured documents and graph heads, then replays committed answers without a model or credentials.
+Missing answers and violations fail the build and name the page, section, and rule.
+
+Run `pagegraph claims check` after changing prose, facts, context, or rules, then review and commit
+`.pagegraph/decisions/claims/`. The cache key includes the rule definition fingerprint, model, and
+input hash. Cached answers are reused; `--refresh` asks again and replaces them. The command reports
+cached and asked counts and exits nonzero on violations. Set `TYPESAFE_API_KEY` when answers need
+asking. `pagegraph check` also replays configured claims without model calls.
+
+```sh
+pagegraph claims check
+pagegraph claims check --refresh
+pagegraph claims check --dev http://localhost:3000
+```
+
+`claims.context` supplies policy text to every input. Inputs include the section's authored
+Markdown, messages, all code-owned facts, and other sections marked as evidence. Page metadata is
+judged as a `head` section, including graph pages outside rendered capture. `excludeHeads` accepts
+path globs to omit metadata while keeping captured sections in the gate. The default cutoff is
+`0.8` only when omitted; any probability at or above the configured cutoff is a violation, and
+values below it pass. Changing the cutoff reuses answers and recalculates verdicts.
+
+## Markdown CLI
+
+Inspect captured documents, search page metadata and sections, and maintain a reviewable lock:
+
+```sh
+pagegraph markdown show /pricing
+pagegraph markdown find email
+pagegraph markdown lock
+pagegraph markdown lock --check
+```
+
+`show` prints the page's Markdown twin. `find` reports matching pages and sections.
+`lock` writes `.pagegraph/markdown.lock.json` from document and message hashes, including
+head-only pages; `--check` exits nonzero if the lock is missing or differs. These commands use
+`.pagegraph/documents/` and `.pagegraph/heads.json` from the build. Use `--dev <origin>` to inspect
+the development bundle instead. `--json` emits structured output using the CLI's usual conventions.
+Markdown and claims settings come from `pagegraph()` in Vite, including the canonical Markdown
+origin and facts module. Built-mode commands read Vite with `command: "build"` and
+`mode: "production"`; `--dev` reads `command: "serve"` and `mode: "development"`.
+Put CLI policies and the graph loader in `pagegraph.config.ts`.
+
 ## CLI
 
-The graph commands acquire your graph through `seo.config.ts` at the app root. A
+The graph commands acquire your graph through `pagegraph.config.ts` at the app root.
+Rename an existing `seo.config.ts`, `.js`, or `.mjs` to its `pagegraph.config.*` equivalent.
+The file holds CLI policies and `loadGraph`; site identity and robots policy come from the
+loader result, and Markdown and claims settings come from the Vite plugin. A
 TanStack Start app uses `tanstackStartGraph` (above), which also supplies the robots
-policy. Otherwise `viteGraphLoader` evaluates your graph module inside a headless Vite
-server, so path aliases, content plugins, and virtual modules all resolve:
+policy and site identity from `pagegraph()`, using build settings in production mode by default.
+Pass `command: "serve", mode: "development"` to inspect a development configuration instead.
+Otherwise `viteGraphLoader` evaluates your graph
+module inside a headless Vite server, so path aliases, content plugins, and virtual modules all resolve:
 
 ```ts
-// seo.config.ts
+// pagegraph.config.ts
 import { defineSeoConfig, viteGraphLoader } from "pagegraph/config";
+import { routeConfig } from "./src/lib/route-config";
 
 export default defineSeoConfig({
-  origin: "https://example.com",
-  disallow: routeConfig.robotsExclusions,
-  contentSignal: "search=yes, ai-input=yes, ai-train=yes",
   // Fail `check` unless each named money page has enough contextual links.
   coverage: [{ path: "/pricing", minInbound: 2 }, { path: "/features/*", minInbound: 1 }],
   loadGraph: viteGraphLoader({
     root: import.meta.dirname,
     entry: "/lib/seo/graph.ts",
     exportName: "loadSeoGraph",
+    site: {
+      origin: "https://example.com",
+      indexable: true,
+      robots: { disallow: routeConfig.robotsExclusions, contentSignal: "search=yes, ai-input=yes, ai-train=yes" },
+    },
   }),
 });
 ```
@@ -461,7 +713,7 @@ pagegraph graph                 # the graph as a tree · --format mermaid | json
 pagegraph inspect /pricing      # one node: policy, sitemap status, in/out edges
 pagegraph inspect <url> --live  # fetch a deployed page, validate its rendered <head>
 pagegraph links verify <url>    # crawl served HTML: depth, orphans, declared-vs-rendered
-pagegraph links verify <url> --assert-coverage  # also assert seo.config.ts coverage on served anchors
+pagegraph links verify <url> --assert-coverage  # also assert pagegraph.config.ts coverage on served anchors
 pagegraph links verify <url> --emit-rendered <file>  # save the rendered edge set
 pagegraph links candidates      # propose contextual links from the declared graph
 pagegraph research keywords --query "email api"  # combine graph, Executor, and Jev evidence
@@ -477,7 +729,7 @@ Stdout is data, stderr is status — `pagegraph check --json | jq` just works.
 `pagegraph links verify` crawls a site's served HTML — through the same DNS-pinned,
 private-IP-blocked HTTP path as `pagegraph audit` — and reports what a crawler
 actually receives: the real homepage depth, the pages with no incoming internal
-edge (rendered orphans), and, when the app has a `seo.config.ts`, the
+edge (rendered orphans), and, when the app has a `pagegraph.config.ts`, the
 declared-vs-rendered link diff. It is bounded with `--limit` and needs no
 framework or config. Discovery reads same-origin `robots.txt` and bounded
 sitemaps before following page anchors, so a sitemap-only page can appear as an
@@ -532,7 +784,7 @@ It is also a drop-in input for `pagegraph links candidates --rendered`.
 
 ### Assert coverage on the rendered graph
 
-`pagegraph check` evaluates the `seo.config.ts` `coverage` rules against the
+`pagegraph check` evaluates the `pagegraph.config.ts` `coverage` rules against the
 **declared** graph; `pagegraph links verify --assert-coverage` evaluates the same
 rules against the anchors a crawler **actually receives**. Only same-origin
 body-region anchors count — nav, header, and footer links are chrome — which is
@@ -549,7 +801,7 @@ non-zero) rather than reporting a false pass when the crawl outran `--limit`, a
 page failed to fetch (its anchors are missing), a body hit `--max-body-bytes`, the
 robots or sitemap discovery is incomplete, the
 config declares no `coverage`, or the artifact's origin differs from
-`seo.config.ts`. Under `--assert-coverage` the report gains a `coverage` block
+`pagegraph.config.ts`. Under `--assert-coverage` the report gains a `coverage` block
 (`{ rules, ok, violations }`); the default `--json` summary is unchanged.
 
 ### Propose contextual links
@@ -615,7 +867,7 @@ both `links candidates --site` and `improve links --suggestions`.
 
 ### Contextual-link coverage
 
-Declare a contextual-link coverage policy in `seo.config.ts` (a `coverage` array
+Declare a contextual-link coverage policy in `pagegraph.config.ts` (a `coverage` array
 of `{ path, minInbound }`), or pass repeatable `--require-inbound "<path-glob>=<n>"`
 flags to override it for one run. `pagegraph check` then fails (exit 1) unless
 every sitemap-eligible page matching the glob has at least `minInbound` incoming
@@ -709,7 +961,7 @@ undated rather than stale; give content its `modifiedAt` (or a route its
 
 ### Audit any website
 
-`pagegraph audit` is framework-independent and does not need `seo.config.ts`. It
+`pagegraph audit` is framework-independent and does not need `pagegraph.config.ts`. It
 validates target URLs before making requests, follows redirects through the same
 validation boundary, inspects the rendered document and discovery files, and
 can collect Lighthouse evidence through a validating proxy.

package/dist/audit.d.ts

@@ -1,6 +1,6 @@
-import "./content-B1cPtL8b.js";
-import * as Context from "effect/Context";
+import "./content-DgNr7apS.js";
 import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
 import * as Layer from "effect/Layer";
 import { Data, Schema } from "effect";
 import "node:net";

package/dist/audit.js

@@ -1,12 +1,13 @@
-import { l as extractAnchors, r as extractPageContent, t as checkPageContent } from "./content-kcEnQdfi.js";
+import { l as extractAnchors, r as extractPageContent, t as checkPageContent } from "./content-CHd0X4s6.js";
 import { mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import * as Context from "effect/Context";
 import * as Data$1 from "effect/Data";
 import * as Effect from "effect/Effect";
+import * as Schema$1 from "effect/Schema";
+import { createHash } from "node:crypto";
+import * as Context from "effect/Context";
 import * as Layer from "effect/Layer";
 import { Data, Schema } from "effect";
-import { createHash } from "node:crypto";
 import { createServer, request } from "node:http";
 import { request as request$1 } from "node:https";
 import { BlockList, connect, isIP } from "node:net";
@@ -16,7 +17,6 @@ import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import * as Option from "effect/Option";
-import * as Schema$1 from "effect/Schema";
 //#region src/audit/rules.ts
 const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 const stringAt = (value, ...keys) => {

package/dist/build-only/audit.js

@@ -1,4 +1,4 @@
-import { t as buildOnlyError } from "../message-DT_CjUdt.js";
+import { t as buildOnlyError } from "../message-CuBjgZ74.js";
 //#region src/build-only/audit.ts
 throw buildOnlyError("pagegraph/audit");
 //#endregion

package/dist/build-only/claims.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/build-only/claims.js

@@ -0,0 +1,6 @@
+import { t as buildOnlyError } from "../message-CuBjgZ74.js";
+//#region src/build-only/claims.ts
+throw buildOnlyError("pagegraph/claims");
+//#endregion
+
+//# sourceMappingURL=claims.js.map

package/dist/build-only/claims.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claims.js","names":[],"sources":["../../src/build-only/claims.ts"],"sourcesContent":["import { buildOnlyError } from \"./message\";\n\nthrow buildOnlyError(\"pagegraph/claims\");\n"],"mappings":";;AAEA,MAAM,eAAe,kBAAkB"}

package/dist/build-only/config.js

@@ -1,4 +1,4 @@
-import { t as buildOnlyError } from "../message-DT_CjUdt.js";
+import { t as buildOnlyError } from "../message-CuBjgZ74.js";
 //#region src/build-only/config.ts
 throw buildOnlyError("pagegraph/config");
 //#endregion

package/dist/build-only/oxlint.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/build-only/oxlint.js

@@ -0,0 +1,6 @@
+import { t as buildOnlyError } from "../message-CuBjgZ74.js";
+//#region src/build-only/oxlint.ts
+throw buildOnlyError("pagegraph/oxlint");
+//#endregion
+
+//# sourceMappingURL=oxlint.js.map

package/dist/build-only/oxlint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oxlint.js","names":[],"sources":["../../src/build-only/oxlint.ts"],"sourcesContent":["import { buildOnlyError } from \"./message\";\n\nthrow buildOnlyError(\"pagegraph/oxlint\");\n"],"mappings":";;AAEA,MAAM,eAAe,kBAAkB"}

package/dist/build-only/tanstack-start.js

@@ -1,4 +1,4 @@
-import { t as buildOnlyError } from "../message-DT_CjUdt.js";
+import { t as buildOnlyError } from "../message-CuBjgZ74.js";
 //#region src/build-only/tanstack-start.ts
 throw buildOnlyError("pagegraph/tanstack-start");
 //#endregion

package/dist/build-only/vite.js

@@ -1,4 +1,4 @@
-import { t as buildOnlyError } from "../message-DT_CjUdt.js";
+import { t as buildOnlyError } from "../message-CuBjgZ74.js";
 //#region src/build-only/vite.ts
 throw buildOnlyError("pagegraph/vite");
 //#endregion

package/dist/{checks-uZk5Em9A.js → checks-BS-aDXB_.js}

@@ -328,7 +328,7 @@ function checkCoverage(graph, rules) {
 * 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
+* in `pagegraph.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`).
 */
@@ -349,4 +349,4 @@ const hasStructuralViolations = (violations) => violations.some((violation) => v
 //#endregion
 export { globToRegExp as a, checkRenderedCoverage as i, checkFreshness as n, hasStructuralViolations as o, checkGraph as r, freshnessReport as s, checkCoverage as t };
 
-//# sourceMappingURL=checks-uZk5Em9A.js.map
+//# sourceMappingURL=checks-BS-aDXB_.js.map

package/dist/checks-BS-aDXB_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks-BS-aDXB_.js","names":[],"sources":["../src/core/freshness.ts","../src/core/checks.ts"],"sourcesContent":["/**\n * Freshness: how long ago each indexable page last changed, by the dates its\n * declaration carries ({@link lastModified}). Pure — the caller injects `now`,\n * so a test and the CLI read the same verdict from the same graph.\n *\n * Only sitemap-eligible pages are judged: a noindex or redirect page is not a\n * refresh candidate. A page with no date is reported as `undated` rather than\n * stale, because age cannot be inferred; the sitemap omits its `<lastmod>` too.\n */\n\nimport type { SeoKind } from \"./declare\";\nimport type { SeoGraph, SeoSource } from \"./graph\";\nimport { isSitemapEligible, lastModified, parseDeclaredDate } from \"./projections\";\n\n/** Project policy: pages whose last change is older than this are stale. */\nexport interface FreshnessPolicy {\n  readonly maxAgeDays: number;\n}\n\nexport interface FreshnessEntry {\n  readonly path: string;\n  readonly kind: SeoKind;\n  readonly source: SeoSource;\n  /** The declared date, normalized to ISO 8601. */\n  readonly lastModified: string;\n  /** Whole days between `lastModified` and the report's `asOf`. */\n  readonly ageDays: number;\n}\n\nexport interface FreshnessReport {\n  readonly asOf: string;\n  readonly maxAgeDays: number;\n  /** Pages older than `maxAgeDays`, oldest first: the refresh queue. */\n  readonly stale: ReadonlyArray<FreshnessEntry>;\n  /** Dated pages within `maxAgeDays`, newest first. */\n  readonly fresh: ReadonlyArray<FreshnessEntry>;\n  /** Sitemap-eligible pages that declare no date, in graph order. */\n  readonly undated: ReadonlyArray<string>;\n  /** Sitemap-eligible pages whose date does not parse; `check` fails on each. */\n  readonly invalid: ReadonlyArray<string>;\n}\n\nconst DAY_MS = 86_400_000;\n\n/**\n * Split the graph's sitemap-eligible pages into stale, fresh, undated, and\n * invalid. An invalid date cannot be aged, but it is listed so a report never\n * reads as complete while it skipped a page.\n */\nexport function freshnessReport(\n  graph: SeoGraph,\n  policy: FreshnessPolicy,\n  now: Date,\n): FreshnessReport {\n  const stale: Array<FreshnessEntry> = [];\n  const fresh: Array<FreshnessEntry> = [];\n  const undated: Array<string> = [];\n  const invalid: Array<string> = [];\n\n  for (const node of graph.nodes.values()) {\n    if (!isSitemapEligible(node)) continue;\n    const declared = lastModified(node);\n    if (declared === undefined) {\n      undated.push(node.path);\n      continue;\n    }\n    const time = parseDeclaredDate(declared);\n    if (time === undefined) {\n      invalid.push(node.path);\n      continue;\n    }\n    const entry: FreshnessEntry = {\n      path: node.path,\n      kind: node.kind,\n      source: node.source,\n      lastModified: new Date(time).toISOString(),\n      ageDays: Math.max(0, Math.floor((now.getTime() - time) / DAY_MS)),\n    };\n    (entry.ageDays > policy.maxAgeDays ? stale : fresh).push(entry);\n  }\n\n  stale.sort((a, b) => b.ageDays - a.ageDays || (a.path < b.path ? -1 : 1));\n  fresh.sort((a, b) => a.ageDays - b.ageDays || (a.path < b.path ? -1 : 1));\n  return {\n    asOf: now.toISOString(),\n    maxAgeDays: policy.maxAgeDays,\n    stale,\n    fresh,\n    undated,\n    invalid,\n  };\n}\n","/**\n * The SEO check engine: a set of rules run against the derived {@link SeoGraph}.\n * Pure — no I/O, no `clientEnv`, no React. The CLI's `pagegraph check` command and the\n * vitest suite both call {@link checkGraph}; nothing else derives correctness.\n *\n * Two severities, mapped to the CLI's exit contract:\n *  - `structural` — a declaration is internally broken (a link points nowhere, a\n *    card would render empty, a page contradicts its own robots/sitemap intent).\n *    Any structural violation fails `pagegraph check` (exit 1); these must not ship.\n *  - `editorial` — a quality smell (duplicate or mis-sized titles/descriptions).\n *    Reported as warnings; `pagegraph check` still exits 0 when only these are present.\n *\n * The graph only knows what declarations and frontmatter carry, so the rules are\n * scoped to that: per-node title/description live only on collection *instances*,\n * never on structural route nodes (whose head tags are composed at render time and\n * are not in the graph). Rules are data-driven and listed once in\n * {@link CHECK_RULES}.\n */\n\nimport type { SitemapPolicy } from \"./declare\";\nimport { freshnessReport, type FreshnessPolicy } from \"./freshness\";\nimport type { SeoGraph, SeoNode } from \"./graph\";\nimport type { LinkEdge } from \"./links\";\nimport { isSitemapEligible, parseDeclaredDate } from \"./projections\";\n\nexport type Severity = \"structural\" | \"editorial\";\n\nexport interface Violation {\n  severity: Severity;\n  rule: string;\n  path?: string | undefined;\n  message: string;\n  fix?: string | undefined;\n}\n\n/**\n * A contextual-link coverage rule: every sitemap-eligible page matching the\n * `path` glob must have at least `minInbound` incoming contextual links. Unlike\n * the static rules, these come from project policy (a CLI flag or\n * `pagegraph.config.ts`), because \"which pages are money pages\" is app knowledge.\n *\n * The same rule shape is evaluated twice: `checkCoverage` counts declared\n * `related` edges, and `checkRenderedCoverage` counts the contextual anchors a\n * crawl actually served. The target universe is always the declared graph's\n * sitemap-eligible pages — the rendered pass only swaps the edge source.\n */\nexport interface CoverageRule {\n  /** Path glob: `*` matches within a segment, `**` matches across segments. */\n  readonly path: string;\n  /** Minimum incoming contextual links the matched page needs. */\n  readonly minInbound: number;\n}\n\n/** A single finding before its rule's `severity`/`rule` name are attached. */\ninterface RawViolation {\n  path?: string | undefined;\n  message: string;\n  fix?: string | undefined;\n}\n\ninterface CheckRule {\n  readonly name: string;\n  readonly severity: Severity;\n  readonly evaluate: (graph: SeoGraph) => ReadonlyArray<RawViolation>;\n}\n\n/** A positive sitemap policy — the author asked for this page to be indexed. */\nconst hasPositiveSitemap = (sitemap: SitemapPolicy | false | undefined): sitemap is SitemapPolicy =>\n  sitemap !== undefined && sitemap !== false;\n\n/** Content and manifest instances carry page-level title/description. */\nconst isInstance = (node: SeoNode): boolean => node.source !== \"route\";\n\n/** Group instance nodes by a present, non-empty string field for duplicate detection. */\nconst groupInstancesBy = (\n  graph: SeoGraph,\n  field: (node: SeoNode) => string | undefined,\n): Map<string, Array<SeoNode>> => {\n  const groups = new Map<string, Array<SeoNode>>();\n  for (const node of graph.nodes.values()) {\n    if (!isInstance(node)) continue;\n    const value = field(node)?.trim();\n    if (!value) continue;\n    const bucket = groups.get(value);\n    if (bucket) bucket.push(node);\n    else groups.set(value, [node]);\n  }\n  return groups;\n};\n\nconst DESCRIPTION_MAX = 160;\nconst DESCRIPTION_MIN = 50;\n\n/**\n * Every check, in one place. `checkGraph` runs them in order and stamps each\n * finding with its rule name and severity, so the output is grouped by rule and\n * deterministic (nodes iterate in graph insertion order, edges in array order).\n */\nconst CHECK_RULES: ReadonlyArray<CheckRule> = [\n  {\n    name: \"path-owner-collision\",\n    severity: \"structural\",\n    evaluate: (graph) =>\n      (graph.collisions ?? []).map((collision) => ({\n        path: collision.path,\n        message: `Canonical path \"${collision.path}\" is owned by multiple sources: ${collision.sources.join(\", \")}.`,\n        fix: \"Give every concrete page one canonical path and one graph owner.\",\n      })),\n  },\n  {\n    name: \"canonical-path-collision\",\n    severity: \"structural\",\n    evaluate: (graph) => {\n      const groups = new Map<string, Array<string>>();\n      for (const path of graph.nodes.keys()) {\n        const canonical = path.toLowerCase().replace(/\\/$/, \"\") || \"/\";\n        const paths = groups.get(canonical);\n        if (paths) paths.push(path);\n        else groups.set(canonical, [path]);\n      }\n      return [...groups.values()]\n        .filter((paths) => paths.length > 1)\n        .flatMap((paths) =>\n          paths.map((path) => ({\n            path,\n            message: `Canonical path collides with ${paths.filter((candidate) => candidate !== path).join(\", \")}.`,\n            fix: \"Use one lowercase, trailing-slash-normalized canonical path.\",\n          })),\n        );\n    },\n  },\n  {\n    name: \"self-edge\",\n    severity: \"structural\",\n    evaluate: (graph) =>\n      graph.edges\n        .filter((edge) => edge.from === edge.to)\n        .map((edge) => ({\n          path: edge.from,\n          message: `${edge.type} edge points back to its own source node.`,\n          fix: \"Remove the self-reference from the canonical manifest or route declaration.\",\n        })),\n  },\n  {\n    name: \"duplicate-edge\",\n    severity: \"structural\",\n    evaluate: (graph) => {\n      const seen = new Set<string>();\n      const duplicates: Array<RawViolation> = [];\n      for (const edge of graph.edges) {\n        const key = `${edge.from}\\u0000${edge.to}\\u0000${edge.type}`;\n        if (seen.has(key)) {\n          duplicates.push({\n            path: edge.from,\n            message: `Duplicate ${edge.type} edge from \"${edge.from}\" to \"${edge.to}\".`,\n            fix: \"Declare each graph relationship exactly once.\",\n          });\n        } else {\n          seen.add(key);\n        }\n      }\n      return duplicates;\n    },\n  },\n  {\n    // A `related` or `redirect` edge points at a path with no node — the target\n    // route/page was renamed or deleted and the declaration wasn't updated.\n    name: \"dead-edge\",\n    severity: \"structural\",\n    evaluate: (graph) =>\n      graph.edges\n        .filter((edge) => edge.type !== \"crumb-parent\" && !graph.nodes.has(edge.to))\n        .map((edge) => ({\n          path: edge.from,\n          message: `${edge.type} edge from \"${edge.from}\" points at \"${edge.to}\", which is not a node in the graph.`,\n          fix: `Update the ${edge.type === \"redirect\" ? \"redirectTo\" : \"related\"} target on the \"${edge.from}\" route, or restore \"${edge.to}\".`,\n        })),\n  },\n  {\n    // A content instance with no usable title can't render a legible <title> or card.\n    name: \"instance-missing-title\",\n    severity: \"structural\",\n    evaluate: (graph) =>\n      [...graph.nodes.values()]\n        .filter((node) => isInstance(node) && !node.instance?.title.trim())\n        .map((node) => ({\n          path: node.path,\n          message: `Content page \"${node.path}\" has no title.`,\n          fix: \"Add a `title` to the page frontmatter.\",\n        })),\n  },\n  {\n    // The declaration asks for the page to be in the sitemap yet also marks it\n    // noindex — contradictory intent. The projection resolves it (noindex wins,\n    // excluded), but the declaration should say one thing.\n    name: \"sitemap-noindex-contradiction\",\n    severity: \"structural\",\n    evaluate: (graph) =>\n      [...graph.nodes.values()]\n        .filter(\n          (node) =>\n            hasPositiveSitemap(node.policy.sitemap) &&\n            node.policy.robots?.toLowerCase().includes(\"noindex\"),\n        )\n        .map((node) => ({\n          path: node.path,\n          message: `\"${node.path}\" declares a sitemap policy but its robots value is \"${node.policy.robots}\".`,\n          fix: \"Drop the sitemap policy (or set `sitemap: false`) on a noindex page, or remove the noindex robots value.\",\n        })),\n  },\n  {\n    // Robots declarations are house-convention lowercase: the sitemap projection\n    // matches `includes(\"noindex\")` literally, so a miscased value (\"Noindex\")\n    // would silently stay sitemap-eligible. This gate makes that unrepresentable.\n    name: \"robots-not-lowercase\",\n    severity: \"structural\",\n    evaluate: (graph) =>\n      [...graph.nodes.values()]\n        .filter(\n          (node) =>\n            node.policy.robots !== undefined &&\n            node.policy.robots !== node.policy.robots.toLowerCase(),\n        )\n        .map((node) => ({\n          path: node.path,\n          message: `\"${node.path}\" declares robots \"${node.policy.robots}\" — robots values must be lowercase.`,\n          fix: 'Lowercase the robots declaration (e.g. \"noindex, follow\").',\n        })),\n  },\n  {\n    // A `related` card for a route target renders from that route's `link`\n    // metadata; without it the card has no title/description and renders empty.\n    // (Content-instance targets render from their frontmatter, so they're exempt.)\n    name: \"related-target-missing-link\",\n    severity: \"structural\",\n    evaluate: (graph) => {\n      const linklessTargets = new Set<string>();\n      for (const edge of graph.edges) {\n        if (edge.type !== \"related\") continue;\n        const target = graph.nodes.get(edge.to);\n        if (target && target.source === \"route\" && target.policy.link === undefined) {\n          linklessTargets.add(edge.to);\n        }\n      }\n      return [...linklessTargets].map((path) => ({\n        path,\n        message: `Route \"${path}\" is a related-link target but declares no link metadata; its card would render empty.`,\n        fix: `Add \\`link: { title, description }\\` to the \"${path}\" route's staticData.seo.`,\n      }));\n    },\n  },\n  {\n    // A redirect/alias node should never advertise itself in the sitemap.\n    name: \"redirect-in-sitemap\",\n    severity: \"structural\",\n    evaluate: (graph) =>\n      [...graph.nodes.values()]\n        .filter(\n          (node) => node.policy.redirectTo !== undefined && hasPositiveSitemap(node.policy.sitemap),\n        )\n        .map((node) => ({\n          path: node.path,\n          message: `Redirect \"${node.path}\" (→ \"${node.policy.redirectTo}\") also declares a sitemap policy.`,\n          fix: \"Remove the sitemap policy from the redirect route; only its target belongs in the sitemap.\",\n        })),\n  },\n  {\n    // Every declared date feeds the sitemap's `<lastmod>`, and the sitemap\n    // projection refuses a date it cannot parse. Catch it here, at the\n    // declaration, instead of as a failed sitemap request.\n    name: \"invalid-date\",\n    severity: \"structural\",\n    evaluate: (graph) =>\n      [...graph.nodes.values()].flatMap((node) => {\n        const dates: Array<[string, string | undefined]> = node.instance\n          ? [\n              [\"publishedAt\", node.instance.publishedAt],\n              [\"modifiedAt\", node.instance.modifiedAt],\n            ]\n          : [[\"modifiedAt\", node.policy.modifiedAt]];\n        return dates.flatMap(([field, value]) =>\n          value !== undefined && parseDeclaredDate(value) === undefined\n            ? [\n                {\n                  path: node.path,\n                  message: `${field} \"${value}\" is not an ISO 8601 date on a real calendar day.`,\n                  fix: `Write ${field} as an ISO 8601 date, e.g. \"2026-09-29\".`,\n                },\n              ]\n            : [],\n        );\n      }),\n  },\n  {\n    name: \"duplicate-title\",\n    severity: \"editorial\",\n    evaluate: (graph) =>\n      [...groupInstancesBy(graph, (node) => node.instance?.title).entries()]\n        .filter(([, nodes]) => nodes.length > 1)\n        .flatMap(([title, nodes]) =>\n          nodes.map((node) => ({\n            path: node.path,\n            message: `Title \"${title}\" is shared by ${nodes.length} pages.`,\n            fix: \"Give each page a distinct title.\",\n          })),\n        ),\n  },\n  {\n    name: \"duplicate-description\",\n    severity: \"editorial\",\n    evaluate: (graph) =>\n      [...groupInstancesBy(graph, (node) => node.instance?.description).entries()]\n        .filter(([, nodes]) => nodes.length > 1)\n        .flatMap(([, nodes]) =>\n          nodes.map((node) => ({\n            path: node.path,\n            message: `Description is shared by ${nodes.length} pages.`,\n            fix: \"Write a distinct meta description for each page.\",\n          })),\n        ),\n  },\n  {\n    // Meta descriptions outside ~50–160 chars either get truncated in SERPs or\n    // read as too thin.\n    name: \"description-length\",\n    severity: \"editorial\",\n    evaluate: (graph) =>\n      [...graph.nodes.values()].flatMap((node) => {\n        if (!isInstance(node)) return [];\n        const description = node.instance?.description?.trim();\n        if (!description) return [];\n        if (description.length > DESCRIPTION_MAX) {\n          return [\n            {\n              path: node.path,\n              message: `Description is ${description.length} chars (max ${DESCRIPTION_MAX}); it will be truncated in results.`,\n              fix: `Trim the description to ${DESCRIPTION_MAX} characters or fewer.`,\n            },\n          ];\n        }\n        if (description.length < DESCRIPTION_MIN) {\n          return [\n            {\n              path: node.path,\n              message: `Description is ${description.length} chars (min ${DESCRIPTION_MIN}); it reads as thin.`,\n              fix: `Expand the description to at least ${DESCRIPTION_MIN} characters.`,\n            },\n          ];\n        }\n        return [];\n      }),\n  },\n];\n\n/**\n * Options for {@link checkGraph}. Freshness needs a clock, and the engine stays\n * pure, so a freshness policy is only accepted together with the `now` it is\n * judged against.\n */\nexport type CheckGraphOptions = {\n  readonly coverage?: ReadonlyArray<CoverageRule> | undefined;\n} & (\n  | { readonly freshness: FreshnessPolicy; readonly now: Date }\n  | { readonly freshness?: undefined; readonly now?: undefined }\n);\n\n/**\n * Run every static rule against the graph, then any caller-supplied\n * {@link CoverageRule}s and freshness policy, and return the flat list of\n * violations. With no options the result is exactly the static rule set.\n */\nexport function checkGraph(graph: SeoGraph, options: CheckGraphOptions = {}): Array<Violation> {\n  const violations: Array<Violation> = CHECK_RULES.flatMap((rule) =>\n    rule.evaluate(graph).map((raw): Violation => ({\n      severity: rule.severity,\n      rule: rule.name,\n      path: raw.path,\n      message: raw.message,\n      fix: raw.fix,\n    })),\n  );\n  const coverage = options.coverage;\n  if (coverage !== undefined && coverage.length > 0) {\n    violations.push(...checkCoverage(graph, coverage));\n  }\n  if (options.freshness !== undefined) {\n    violations.push(...checkFreshness(graph, options.freshness, options.now));\n  }\n  return violations;\n}\n\n/**\n * One editorial `stale-page` violation per sitemap-eligible page whose last\n * declared change is older than the policy allows. Undated pages are not\n * violations: see {@link freshnessReport} for the full picture.\n */\nexport function checkFreshness(\n  graph: SeoGraph,\n  policy: FreshnessPolicy,\n  now: Date,\n): Array<Violation> {\n  return freshnessReport(graph, policy, now).stale.map((entry) => ({\n    severity: \"editorial\",\n    rule: \"stale-page\",\n    path: entry.path,\n    message: `Last changed ${entry.lastModified.slice(0, 10)}, ${entry.ageDays} days ago (limit ${policy.maxAgeDays}).`,\n    fix: \"Review the page; when its content changes, update its modifiedAt.\",\n  }));\n}\n\n/** Escape a glob for `RegExp`, then expand `**`, `*`, and `?` to path-aware forms. */\nexport const globToRegExp = (glob: string): RegExp => {\n  const escaped = glob.replace(/[.+^${}()|[\\]\\\\]/g, \"\\\\$&\");\n  const source = escaped\n    .replace(/\\*\\*/g, \"\\u0000\")\n    .replace(/\\*/g, \"[^/]*\")\n    .replace(/\\?/g, \"[^/]\")\n    .replace(/\\u0000/g, \".*\");\n  return new RegExp(`^${source}$`);\n};\n\n/**\n * The minimal view a coverage rule needs: which paths exist (for the glob), which\n * of them are sitemap-eligible (the enforced set), and how many contextual links\n * each receives. Declared and rendered coverage differ only in how this surface\n * is built, so the rule engine itself stays single-sourced.\n */\ninterface CoverageSurface {\n  readonly paths: ReadonlyArray<string>;\n  readonly eligiblePaths: ReadonlyArray<string>;\n  readonly inbound: (path: string) => number;\n}\n\n/**\n * Enforce contextual-link coverage rules over an explicit surface.\n *\n * A rule that matches no sitemap-eligible page is itself a violation: a typo or\n * a rule aimed at a noindex page would otherwise pass silently forever.\n */\nconst checkCoverageRules = (\n  surface: CoverageSurface,\n  rules: ReadonlyArray<CoverageRule>,\n): Array<Violation> => {\n  const violations: Array<Violation> = [];\n  for (const rule of rules) {\n    const matcher = globToRegExp(rule.path);\n    const matched = surface.paths.filter((path) => matcher.test(path));\n    const eligible = surface.eligiblePaths.filter((path) => matcher.test(path));\n\n    if (eligible.length === 0) {\n      violations.push({\n        severity: \"structural\",\n        rule: \"coverage-rule-unmatched\",\n        message:\n          matched.length === 0\n            ? `Coverage rule \"${rule.path}\" matches no page in the graph.`\n            : `Coverage rule \"${rule.path}\" matches only pages that are not sitemap-eligible.`,\n        fix: \"Point the rule at a sitemap-eligible path, or drop it.\",\n      });\n      continue;\n    }\n\n    for (const path of eligible) {\n      const inbound = surface.inbound(path);\n      if (inbound >= rule.minInbound) continue;\n      violations.push({\n        severity: \"structural\",\n        rule: \"inbound-link-coverage\",\n        path,\n        message: `\"${path}\" has ${inbound} incoming contextual link(s); the coverage rule requires ${rule.minInbound}.`,\n        fix: `Add ${rule.minInbound - inbound} contextual link(s) pointing at \"${path}\".`,\n      });\n    }\n  }\n  return violations;\n};\n\n/** The sitemap-eligible path set of a declared graph, in graph insertion order. */\nconst eligiblePathsOf = (graph: SeoGraph): ReadonlyArray<string> =>\n  [...graph.nodes.values()].filter(isSitemapEligible).map((node) => node.path);\n\n/**\n * Enforce contextual-link coverage against the *declared* graph: only `related`\n * edges count — breadcrumb ancestry is navigation, not context.\n */\nexport function checkCoverage(\n  graph: SeoGraph,\n  rules: ReadonlyArray<CoverageRule>,\n): Array<Violation> {\n  return checkCoverageRules(\n    {\n      paths: [...graph.nodes.keys()],\n      eligiblePaths: eligiblePathsOf(graph),\n      inbound: (path) =>\n        graph.edges.filter((edge) => edge.type === \"related\" && edge.to === path).length,\n    },\n    rules,\n  );\n}\n\n/**\n * Enforce contextual-link coverage against the *rendered* graph: only same-origin\n * body-region anchors count. Nav, header, and footer anchors are site chrome, so\n * a page linked solely from them has no contextual inbound link — the same\n * distinction the declared pass draws by counting `related` edges alone.\n *\n * The target universe is the declared graph's sitemap-eligible pages: the globs\n * in `pagegraph.config.ts` are written against declared paths, and the crawl is what\n * supplies the served edges. Pass the crawl's `internalEdges` (each edge carries\n * its `region`).\n */\nexport function checkRenderedCoverage(\n  graph: SeoGraph,\n  renderedEdges: ReadonlyArray<LinkEdge>,\n  rules: ReadonlyArray<CoverageRule>,\n): Array<Violation> {\n  const inbound = new Map<string, number>();\n  for (const edge of renderedEdges) {\n    if (edge.region !== \"body\") continue;\n    inbound.set(edge.to, (inbound.get(edge.to) ?? 0) + 1);\n  }\n  return checkCoverageRules(\n    {\n      paths: [...graph.nodes.keys()],\n      eligiblePaths: eligiblePathsOf(graph),\n      inbound: (path) => inbound.get(path) ?? 0,\n    },\n    rules,\n  );\n}\n\n/** Structural violations fail `pagegraph check`; editorial-only stays green. */\nexport const hasStructuralViolations = (violations: ReadonlyArray<Violation>): boolean =>\n  violations.some((violation) => violation.severity === \"structural\");\n"],"mappings":"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"}