pagegraph 0.9.0 → 0.10.1

package/dist/{checks-_X8yjMvV.d.ts → content-DVL2iyGU.d.ts}

@@ -1,4 +1,162 @@
 import { AnyRoute, AnyRouteMatch } from "@tanstack/react-router";
+//#region src/core/declare.d.ts
+/**
+ * Consumer-augmented registry.
+ *
+ * ```ts
+ * declare module "pagegraph" {
+ *   interface Register {
+ *     paths: FileRouteTypes["fullPaths"];
+ *     kinds: "page" | "article" | "hub";
+ *   }
+ * }
+ * ```
+ */
+interface Register {}
+/** Every public full path in the consumer's route tree (type-only; erased at runtime). */
+type PublicPath = Register extends {
+  paths: infer P extends string;
+} ? P : string;
+/** The consumer's page taxonomy. A label: nothing in the core branches on it. */
+type SeoKind = Register extends {
+  kinds: infer K extends string;
+} ? K : string;
+interface SitemapPolicy {
+  priority: number;
+  changeFrequency: "weekly" | "monthly";
+}
+interface RouteSeo {
+  kind: SeoKind;
+  /** Breadcrumb label; fn form reads the match (e.g. loaderData frontmatter title). */
+  crumb?: string | ((match: AnyRouteMatch) => string) | undefined;
+  /** false = excluded from sitemap. Absent on non-indexable kinds is fine. */
+  sitemap?: SitemapPolicy | false | undefined;
+  /** meta robots value, e.g. "noindex, follow" on a hub page. */
+  robots?: string | undefined;
+  /** Typed cross-link edges. */
+  related?: ReadonlyArray<PublicPath> | undefined;
+  /** How OTHER pages render a card for this page. */
+  link?: {
+    title: string;
+    description: string;
+  } | undefined;
+  /** This route is a redirect/alias. */
+  redirectTo?: PublicPath | undefined;
+  /**
+   * When this page's content last changed meaningfully, as an ISO 8601 date.
+   * Feeds the sitemap `<lastmod>` and the freshness report. Content instances
+   * carry their own dates instead; a param route's value is never inherited.
+   */
+  modifiedAt?: string | undefined;
+}
+declare module "@tanstack/react-router" {
+  interface StaticDataRouteOption {
+    seo?: RouteSeo | undefined;
+  }
+}
+//#endregion
+//#region src/core/graph.d.ts
+/**
+ * Where a node came from: `"route"` for a structural route declaration, or the
+ * `source` label of the collection that produced the instance (e.g. "blog").
+ */
+type SeoSource = string;
+interface SeoNode {
+  /** Canonical path, no origin (e.g. "/pricing", "/blog/my-post"). */
+  path: string;
+  kind: SeoKind;
+  source: SeoSource;
+  /** Route-declared policy, or synthesized (kind + inherited sitemap) for instances. */
+  policy: RouteSeo;
+  instance?: {
+    title: string;
+    description?: string | undefined;
+    publishedAt?: string | undefined;
+    modifiedAt?: string | undefined;
+  } | undefined;
+}
+type SeoEdgeType = "crumb-parent" | "related" | "redirect" | "collection-member";
+interface SeoEdge {
+  from: string;
+  to: string;
+  type: SeoEdgeType;
+}
+interface SeoGraph {
+  nodes: Map<string, SeoNode>;
+  edges: Array<SeoEdge>;
+  /** Exact-path ownership conflicts encountered while assembling graph sources. */
+  collisions?: ReadonlyArray<{
+    path: string;
+    sources: ReadonlyArray<SeoSource>;
+  }> | undefined;
+}
+/** One concrete page produced by a collection. */
+interface SeoInstance {
+  /** Canonical path of the page (e.g. "/blog/my-post"). */
+  readonly path: string;
+  readonly title: string;
+  readonly description?: string | undefined;
+  readonly publishedAt?: string | undefined;
+  readonly modifiedAt?: string | undefined;
+}
+interface SeoCollection {
+  /**
+   * The param route these instances render through (e.g. "/blog/$slug"). Instances
+   * inherit this route's declared policy (kind + sitemap) — the graph reads it from
+   * the structural node, so declarations stay the single source of truth.
+   */
+  readonly route: PublicPath;
+  /** The `source` stamped on every node this collection produces (e.g. "blog"). */
+  readonly source: SeoSource;
+  readonly instances: ReadonlyArray<SeoInstance>;
+  /** Edges the collection declares between its instances and the rest of the graph. */
+  readonly edges?: ReadonlyArray<SeoEdge> | undefined;
+}
+interface BuildSeoGraphInput {
+  readonly routeTree: AnyRoute;
+  readonly collections?: ReadonlyArray<SeoCollection> | undefined;
+}
+/**
+ * Build the SEO graph from route declarations and content collections.
+ *
+ * Synchronous: the caller materializes its collections before calling, so there is
+ * no async work here. Callers own the origin.
+ */
+declare function buildSeoGraph(input: BuildSeoGraphInput): SeoGraph;
+//#endregion
+//#region src/core/freshness.d.ts
+/** Project policy: pages whose last change is older than this are stale. */
+interface FreshnessPolicy {
+  readonly maxAgeDays: number;
+}
+interface FreshnessEntry {
+  readonly path: string;
+  readonly kind: SeoKind;
+  readonly source: SeoSource;
+  /** The declared date, normalized to ISO 8601. */
+  readonly lastModified: string;
+  /** Whole days between `lastModified` and the report's `asOf`. */
+  readonly ageDays: number;
+}
+interface FreshnessReport {
+  readonly asOf: string;
+  readonly maxAgeDays: number;
+  /** Pages older than `maxAgeDays`, oldest first: the refresh queue. */
+  readonly stale: ReadonlyArray<FreshnessEntry>;
+  /** Dated pages within `maxAgeDays`, newest first. */
+  readonly fresh: ReadonlyArray<FreshnessEntry>;
+  /** Sitemap-eligible pages that declare no date, in graph order. */
+  readonly undated: ReadonlyArray<string>;
+  /** Sitemap-eligible pages whose date does not parse; `check` fails on each. */
+  readonly invalid: ReadonlyArray<string>;
+}
+/**
+ * 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.
+ */
+declare function freshnessReport(graph: SeoGraph, policy: FreshnessPolicy, now: Date): FreshnessReport;
+//#endregion
 //#region src/core/links.d.ts
 /**
  * Pure link-graph utilities: read anchors out of rendered HTML, model the
@@ -146,125 +304,6 @@ declare const RENDERED_EDGE_ARTIFACT_SCHEMA_VERSION: 1;
  */
 declare const decodeRenderedEdgeArtifact: (input: unknown) => RenderedEdgeArtifact;
 //#endregion
-//#region src/core/declare.d.ts
-/**
- * Consumer-augmented registry.
- *
- * ```ts
- * declare module "pagegraph" {
- *   interface Register {
- *     paths: FileRouteTypes["fullPaths"];
- *     kinds: "page" | "article" | "hub";
- *   }
- * }
- * ```
- */
-interface Register {}
-/** Every public full path in the consumer's route tree (type-only; erased at runtime). */
-type PublicPath = Register extends {
-  paths: infer P extends string;
-} ? P : string;
-/** The consumer's page taxonomy. A label: nothing in the core branches on it. */
-type SeoKind = Register extends {
-  kinds: infer K extends string;
-} ? K : string;
-interface SitemapPolicy {
-  priority: number;
-  changeFrequency: "weekly" | "monthly";
-}
-interface RouteSeo {
-  kind: SeoKind;
-  /** Breadcrumb label; fn form reads the match (e.g. loaderData frontmatter title). */
-  crumb?: string | ((match: AnyRouteMatch) => string) | undefined;
-  /** false = excluded from sitemap. Absent on non-indexable kinds is fine. */
-  sitemap?: SitemapPolicy | false | undefined;
-  /** meta robots value, e.g. "noindex, follow" on a hub page. */
-  robots?: string | undefined;
-  /** Typed cross-link edges. */
-  related?: ReadonlyArray<PublicPath> | undefined;
-  /** How OTHER pages render a card for this page. */
-  link?: {
-    title: string;
-    description: string;
-  } | undefined;
-  /** This route is a redirect/alias. */
-  redirectTo?: PublicPath | undefined;
-}
-declare module "@tanstack/react-router" {
-  interface StaticDataRouteOption {
-    seo?: RouteSeo | undefined;
-  }
-}
-//#endregion
-//#region src/core/graph.d.ts
-/**
- * Where a node came from: `"route"` for a structural route declaration, or the
- * `source` label of the collection that produced the instance (e.g. "blog").
- */
-type SeoSource = string;
-interface SeoNode {
-  /** Canonical path, no origin (e.g. "/pricing", "/blog/my-post"). */
-  path: string;
-  kind: SeoKind;
-  source: SeoSource;
-  /** Route-declared policy, or synthesized (kind + inherited sitemap) for instances. */
-  policy: RouteSeo;
-  instance?: {
-    title: string;
-    description?: string | undefined;
-    publishedAt?: string | undefined;
-    modifiedAt?: string | undefined;
-  } | undefined;
-}
-type SeoEdgeType = "crumb-parent" | "related" | "redirect" | "collection-member";
-interface SeoEdge {
-  from: string;
-  to: string;
-  type: SeoEdgeType;
-}
-interface SeoGraph {
-  nodes: Map<string, SeoNode>;
-  edges: Array<SeoEdge>;
-  /** Exact-path ownership conflicts encountered while assembling graph sources. */
-  collisions?: ReadonlyArray<{
-    path: string;
-    sources: ReadonlyArray<SeoSource>;
-  }> | undefined;
-}
-/** One concrete page produced by a collection. */
-interface SeoInstance {
-  /** Canonical path of the page (e.g. "/blog/my-post"). */
-  readonly path: string;
-  readonly title: string;
-  readonly description?: string | undefined;
-  readonly publishedAt?: string | undefined;
-  readonly modifiedAt?: string | undefined;
-}
-interface SeoCollection {
-  /**
-   * The param route these instances render through (e.g. "/blog/$slug"). Instances
-   * inherit this route's declared policy (kind + sitemap) — the graph reads it from
-   * the structural node, so declarations stay the single source of truth.
-   */
-  readonly route: PublicPath;
-  /** The `source` stamped on every node this collection produces (e.g. "blog"). */
-  readonly source: SeoSource;
-  readonly instances: ReadonlyArray<SeoInstance>;
-  /** Edges the collection declares between its instances and the rest of the graph. */
-  readonly edges?: ReadonlyArray<SeoEdge> | undefined;
-}
-interface BuildSeoGraphInput {
-  readonly routeTree: AnyRoute;
-  readonly collections?: ReadonlyArray<SeoCollection> | undefined;
-}
-/**
- * Build the SEO graph from route declarations and content collections.
- *
- * Synchronous: the caller materializes its collections before calling, so there is
- * no async work here. Callers own the origin.
- */
-declare function buildSeoGraph(input: BuildSeoGraphInput): SeoGraph;
-//#endregion
 //#region src/core/checks.d.ts
 type Severity = "structural" | "editorial";
 interface Violation {
@@ -292,13 +331,31 @@ interface CoverageRule {
   readonly minInbound: number;
 }
 /**
- * Run every static rule against the graph, then any caller-supplied
- * {@link CoverageRule}s, and return the flat list of violations. With no
- * `coverage` option the result is exactly the static rule set.
+ * Options for {@link checkGraph}. Freshness needs a clock, and the engine stays
+ * pure, so a freshness policy is only accepted together with the `now` it is
+ * judged against.
  */
-declare function checkGraph(graph: SeoGraph, options?: {
+type CheckGraphOptions = {
   readonly coverage?: ReadonlyArray<CoverageRule> | undefined;
-}): Array<Violation>;
+} & ({
+  readonly freshness: FreshnessPolicy;
+  readonly now: Date;
+} | {
+  readonly freshness?: undefined;
+  readonly now?: undefined;
+});
+/**
+ * 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.
+ */
+declare function checkGraph(graph: SeoGraph, options?: CheckGraphOptions): Array<Violation>;
+/**
+ * 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.
+ */
+declare function checkFreshness(graph: SeoGraph, policy: FreshnessPolicy, now: Date): Array<Violation>;
 /**
  * Enforce contextual-link coverage against the *declared* graph: only `related`
  * edges count — breadcrumb ancestry is navigation, not context.
@@ -319,5 +376,86 @@ declare function checkRenderedCoverage(graph: SeoGraph, renderedEdges: ReadonlyA
 /** Structural violations fail `pagegraph check`; editorial-only stays green. */
 declare const hasStructuralViolations: (violations: ReadonlyArray<Violation>) => boolean;
 //#endregion
-export { RenderedGraph as A, AnchorRegion as C, RenderedEdgeArtifact as D, RENDERED_EDGE_ARTIFACT_SCHEMA_VERSION as E, diffLinkGraph as F, extractAnchors as I, normalizePath as L, SimpleEdge as M, buildRenderedGraph as N, RenderedEdgeArtifactCrawl as O, decodeRenderedEdgeArtifact as P, renderedGraphFromEdges as R, Anchor as S, LinkGraphDiff as T, PublicPath as _, checkGraph as a, SeoKind as b, BuildSeoGraphInput as c, SeoEdgeType as d, SeoGraph as f, buildSeoGraph as g, SeoSource as h, checkCoverage as i, RenderedPage as j, RenderedEdgeFailure as k, SeoCollection as l, SeoNode as m, Severity as n, checkRenderedCoverage as o, SeoInstance as p, Violation as r, hasStructuralViolations as s, CoverageRule as t, SeoEdge as u, Register as v, LinkEdge as w, SitemapPolicy as x, RouteSeo as y };
-//# sourceMappingURL=checks-_X8yjMvV.d.ts.map
+//#region src/core/content.d.ts
+interface Heading {
+  readonly level: number;
+  readonly text: string;
+}
+/** A JSON-LD object that carries an `@type`, found at any depth of any block. */
+type JsonLdNode = Readonly<Record<string, unknown>>;
+/** What a rendered document says, reduced to the fields the content rules read. */
+interface PageContent {
+  readonly title: string | undefined;
+  readonly description: string | undefined;
+  readonly robots: string | undefined;
+  readonly canonical: string | undefined;
+  /** Every H1 in the body, in document order, by accessible text. */
+  readonly h1: ReadonlyArray<string>;
+  /** Headings in the main content region (`<main>`, else the body without nav and footer). */
+  readonly outline: ReadonlyArray<Heading>;
+  /** Words of visible text in the main content region. */
+  readonly wordCount: number;
+  /** Visible body text with whitespace collapsed; scripts, styles, and templates removed. */
+  readonly text: string;
+  /** Every typed JSON-LD node on the page, flattened out of arrays, `@graph`, and nesting. */
+  readonly jsonLd: ReadonlyArray<JsonLdNode>;
+}
+type ContentRuleName = "missing-h1" | "multiple-h1" | "empty-h1" | "heading-level-skip" | "h1-title-mismatch" | "faq-not-visible" | "offer-price-not-visible" | "webpage-head-mismatch" | "thin-content";
+interface ContentFinding {
+  readonly rule: ContentRuleName;
+  readonly severity: Severity;
+  readonly message: string;
+  readonly fix: string;
+}
+interface ContentCheckOptions {
+  /** Minimum words of main-region text; omit to skip the `thin-content` rule. */
+  readonly minWords?: number | undefined;
+}
+/** Reduce a rendered HTML document to the fields the content rules read. Pure. */
+declare const extractPageContent: (html: string) => PageContent;
+/** Run every content rule against one rendered page. Graph-independent; pure. */
+declare const checkPageContent: (content: PageContent, options?: ContentCheckOptions) => Array<ContentFinding>;
+/** A word-count floor for sitemap-eligible pages matching a path glob. */
+interface WordCountRule {
+  /** Path glob: `*` matches within a segment, `**` matches across segments. */
+  readonly path: string;
+  readonly minWords: number;
+}
+/** Project policy for rendered content checks. */
+interface ContentPolicy {
+  /** Word-count floors; a page matching several rules must meet the highest. */
+  readonly minWords?: ReadonlyArray<WordCountRule> | undefined;
+}
+/** One declared page as the server rendered it, or why it could not be read. */
+type RenderedDocument = {
+  readonly path: string;
+  readonly ok: true;
+  /** Path of the final response URL, after redirects, encoded or not. */
+  readonly finalPath: string;
+  readonly html: string;
+} | {
+  readonly path: string;
+  readonly ok: false;
+  readonly error: string;
+};
+/**
+ * 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.
+ */
+declare const renderedCheckTargets: (graph: SeoGraph) => Array<string>;
+/**
+ * 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.
+ */
+declare function checkRenderedContent(graph: SeoGraph, documents: ReadonlyArray<RenderedDocument>, policy?: ContentPolicy): Array<Violation>;
+//#endregion
+export { PublicPath as $, RenderedEdgeFailure as A, FreshnessEntry as B, Anchor as C, RENDERED_EDGE_ARTIFACT_SCHEMA_VERSION as D, LinkGraphDiff as E, decodeRenderedEdgeArtifact as F, SeoCollection as G, FreshnessReport as H, diffLinkGraph as I, SeoGraph as J, SeoEdge as K, extractAnchors as L, RenderedPage as M, SimpleEdge as N, RenderedEdgeArtifact as O, buildRenderedGraph as P, buildSeoGraph as Q, normalizePath as R, hasStructuralViolations as S, LinkEdge as T, freshnessReport as U, FreshnessPolicy as V, BuildSeoGraphInput as W, SeoNode as X, SeoInstance as Y, SeoSource as Z, Violation as _, Heading as a, checkGraph as b, RenderedDocument as c, checkRenderedContent as d, Register as et, extractPageContent as f, Severity as g, CoverageRule as h, ContentRuleName as i, RenderedGraph as j, RenderedEdgeArtifactCrawl as k, WordCountRule as l, CheckGraphOptions as m, ContentFinding as n, SeoKind as nt, JsonLdNode as o, renderedCheckTargets as p, SeoEdgeType as q, ContentPolicy as r, SitemapPolicy as rt, PageContent as s, ContentCheckOptions as t, RouteSeo as tt, checkPageContent as u, checkCoverage as v, AnchorRegion as w, checkRenderedCoverage as x, checkFreshness as y, renderedGraphFromEdges as z };
+//# sourceMappingURL=content-DVL2iyGU.d.ts.map

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { A as RenderedGraph, C as AnchorRegion, D as RenderedEdgeArtifact, E as RENDERED_EDGE_ARTIFACT_SCHEMA_VERSION, F as diffLinkGraph, I as extractAnchors, L as normalizePath, M as SimpleEdge, N as buildRenderedGraph, O as RenderedEdgeArtifactCrawl, P as decodeRenderedEdgeArtifact, R as renderedGraphFromEdges, S as Anchor, T as LinkGraphDiff, _ as PublicPath, a as checkGraph, b as SeoKind, c as BuildSeoGraphInput, d as SeoEdgeType, f as SeoGraph, g as buildSeoGraph, h as SeoSource, i as checkCoverage, j as RenderedPage, k as RenderedEdgeFailure, l as SeoCollection, m as SeoNode, n as Severity, o as checkRenderedCoverage, p as SeoInstance, r as Violation, s as hasStructuralViolations, t as CoverageRule, u as SeoEdge, v as Register, w as LinkEdge, x as SitemapPolicy, y as RouteSeo } from "./checks-_X8yjMvV.js";
+import { $ as PublicPath, A as RenderedEdgeFailure, B as FreshnessEntry, C as Anchor, D as RENDERED_EDGE_ARTIFACT_SCHEMA_VERSION, E as LinkGraphDiff, F as decodeRenderedEdgeArtifact, G as SeoCollection, H as FreshnessReport, I as diffLinkGraph, J as SeoGraph, K as SeoEdge, L as extractAnchors, M as RenderedPage, N as SimpleEdge, O as RenderedEdgeArtifact, P as buildRenderedGraph, Q as buildSeoGraph, R as normalizePath, S as hasStructuralViolations, T as LinkEdge, U as freshnessReport, V as FreshnessPolicy, W as BuildSeoGraphInput, X as SeoNode, Y as SeoInstance, Z as SeoSource, _ as Violation, a as Heading, b as checkGraph, c as RenderedDocument, d as checkRenderedContent, et as Register, f as extractPageContent, g as Severity, h as CoverageRule, i as ContentRuleName, j as RenderedGraph, k as RenderedEdgeArtifactCrawl, l as WordCountRule, m as CheckGraphOptions, n as ContentFinding, nt as SeoKind, o as JsonLdNode, p as renderedCheckTargets, q as SeoEdgeType, r as ContentPolicy, rt as SitemapPolicy, s as PageContent, t as ContentCheckOptions, tt as RouteSeo, u as checkPageContent, v as checkCoverage, w as AnchorRegion, x as checkRenderedCoverage, y as checkFreshness, z as renderedGraphFromEdges } from "./content-DVL2iyGU.js";
 import { AnyRouter } from "@tanstack/react-router";
 //#region src/core/projections.d.ts
 interface ProjectionConfig {
@@ -42,9 +42,16 @@ interface NodeReport {
  */
 declare function isSitemapEligible(node: SeoNode): boolean;
 /**
- * Render sitemap.xml from the graph. Structural route entries emit no `<lastmod>`
- * (a route has no publish date); content instances emit it from their frontmatter.
- * Route entries are sorted by path, then instances follow in collection order.
+ * 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>`.
+ */
+declare function lastModified(node: SeoNode): string | undefined;
+/**
+ * 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.
  */
@@ -185,5 +192,5 @@ declare const hasBlockingIssues: (report: LiveHeadReport) => boolean;
  */
 declare function resolveRouteLink(router: AnyRouter, path: string): RouteSeo["link"];
 //#endregion
-export { type Anchor, type AnchorRegion, type BuildSeoGraphInput, type CoverageRule, type JsonLdReport, type LinkCandidateOptions, type LinkCandidatePair, type LinkCandidateResult, type LinkClusterSummary, type LinkEdge, type LinkGraphDiff, type LiveHeadReport, type NodeReport, type ProjectionConfig, type PublicPath, RENDERED_EDGE_ARTIFACT_SCHEMA_VERSION, type Register, type RenderedEdgeArtifact, type RenderedEdgeArtifactCrawl, type RenderedEdgeFailure, type RenderedGraph, type RenderedPage, type RobotsConfig, type RouteSeo, type SeoCollection, type SeoEdge, type SeoEdgeType, type SeoGraph, type SeoInstance, type SeoKind, type SeoNode, type SeoSource, type Severity, type SimpleEdge, type SitemapPolicy, type Violation, buildRenderedGraph, buildSeoGraph, candidateSourceText, checkCoverage, checkGraph, checkRenderedCoverage, contentSignal, decodeRenderedEdgeArtifact, decodeRenderedEdges, diffLinkGraph, extractAnchors, generateLinkCandidates, hasBlockingIssues, hasStructuralViolations, inspectHtml, inspectNode, isSitemapEligible, matchesClusterFilter, normalizePath, renderRobots, renderSitemap, renderedGraphFromEdges, resolveRouteLink, undirectedEdgeKey };
+export { type Anchor, type AnchorRegion, type BuildSeoGraphInput, type CheckGraphOptions, type ContentCheckOptions, type ContentFinding, type ContentPolicy, type ContentRuleName, type CoverageRule, type FreshnessEntry, type FreshnessPolicy, type FreshnessReport, type Heading, type JsonLdNode, type JsonLdReport, type LinkCandidateOptions, type LinkCandidatePair, type LinkCandidateResult, type LinkClusterSummary, type LinkEdge, type LinkGraphDiff, type LiveHeadReport, type NodeReport, type PageContent, type ProjectionConfig, type PublicPath, RENDERED_EDGE_ARTIFACT_SCHEMA_VERSION, type Register, type RenderedDocument, type RenderedEdgeArtifact, type RenderedEdgeArtifactCrawl, type RenderedEdgeFailure, type RenderedGraph, type RenderedPage, type RobotsConfig, type RouteSeo, type SeoCollection, type SeoEdge, type SeoEdgeType, type SeoGraph, type SeoInstance, type SeoKind, type SeoNode, type SeoSource, type Severity, type SimpleEdge, type SitemapPolicy, type Violation, type WordCountRule, buildRenderedGraph, buildSeoGraph, candidateSourceText, checkCoverage, checkFreshness, checkGraph, checkPageContent, checkRenderedContent, checkRenderedCoverage, contentSignal, decodeRenderedEdgeArtifact, decodeRenderedEdges, diffLinkGraph, extractAnchors, extractPageContent, freshnessReport, generateLinkCandidates, hasBlockingIssues, hasStructuralViolations, inspectHtml, inspectNode, isSitemapEligible, lastModified, matchesClusterFilter, normalizePath, renderRobots, renderSitemap, renderedCheckTargets, renderedGraphFromEdges, resolveRouteLink, undirectedEdgeKey };
 //# sourceMappingURL=index.d.ts.map