dogsbay 0.2.0-beta.11 → 0.2.0-beta.110

package/dist/audit/deliverable-vars.d.ts

@@ -0,0 +1,18 @@
+import type { Issue } from "./types.js";
+/**
+ * Root identifiers referenced by an expression: quoted strings and
+ * dotted property tails stripped, reserved words and numbers excluded.
+ * `platform == "win" and product.name` → {platform, product}.
+ */
+export declare function expressionIdentifiers(expr: string): Set<string>;
+export interface DeliverableVarsOptions {
+    /** Resolved source content directories to scan. */
+    contentDirs: string[];
+    /** The deliverable's merged attribute context. */
+    attributes: Record<string, unknown>;
+    /** Deliverable name, for the message. */
+    deliverable: string;
+    /** Paths in issues are made relative to this root. */
+    siteRoot: string;
+}
+export declare function auditDeliverableVariables(options: DeliverableVarsOptions): Promise<Issue[]>;

package/dist/audit/deliverable-vars.js

@@ -0,0 +1,143 @@
+/**
+ * Undefined-variable audit for deliverables (plans/deliverables.md
+ * Phase 1): preserve-parse every source markdown file, collect the
+ * variables referenced by `{{ … }}` / `{% if … %}` / inline spans, and
+ * report any not defined by the deliverable's merged attribute context.
+ * A `{% if distro == "rosa" %}` whose variable NO deliverable defines is
+ * almost certainly a typo — and invisible at build time, because the
+ * terminal build treats undefined conditions as falsy and silently drops
+ * the block.
+ *
+ * Command-side helper (does I/O); the result is surfaced through a
+ * registered corpus rule closure so it joins the normal audit report and
+ * exit-code accounting.
+ */
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { dogsbayMdToTree } from "@dogsbay/format-dogsbay-md";
+/** Words that appear in expressions but are never variables. */
+const EXPR_RESERVED = new Set([
+    "true",
+    "false",
+    "null",
+    "none",
+    "and",
+    "or",
+    "not",
+    "in",
+    "is",
+    "defined",
+    "undefined",
+]);
+/**
+ * Root identifiers referenced by an expression: quoted strings and
+ * dotted property tails stripped, reserved words and numbers excluded.
+ * `platform == "win" and product.name` → {platform, product}.
+ */
+export function expressionIdentifiers(expr) {
+    const out = new Set();
+    const stripped = expr
+        .replace(/"[^"]*"|'[^']*'/g, " ")
+        .replace(/\.[A-Za-z_][A-Za-z0-9_-]*/g, "");
+    for (const m of stripped.matchAll(/[A-Za-z_][A-Za-z0-9_-]*/g)) {
+        const id = m[0];
+        if (!EXPR_RESERVED.has(id.toLowerCase()))
+            out.add(id);
+    }
+    return out;
+}
+function collectInline(nodes, acc) {
+    for (const n of nodes ?? []) {
+        const t = n.type;
+        if (t === "variable") {
+            for (const id of expressionIdentifiers(n.expr)) {
+                addRef(acc, id, "{{ … }}");
+            }
+        }
+        else if (t === "conditional-span") {
+            const span = n;
+            for (const id of expressionIdentifiers(span.test))
+                addRef(acc, id, "{% if %}");
+            collectInline(span.children, acc);
+        }
+        else {
+            const children = n.children;
+            if (children)
+                collectInline(children, acc);
+        }
+    }
+}
+function addRef(acc, id, kind) {
+    const kinds = acc.refs.get(id) ?? new Set();
+    kinds.add(kind);
+    acc.refs.set(id, kinds);
+}
+function collectBlocks(nodes, acc) {
+    for (const node of nodes) {
+        if (node.type === "conditional") {
+            for (const id of expressionIdentifiers(String(node.props?.test ?? ""))) {
+                addRef(acc, id, "{% if %}");
+            }
+        }
+        else if (node.type === "var-def") {
+            acc.defined.add(String(node.props?.name ?? ""));
+            for (const id of expressionIdentifiers(String(node.props?.value ?? ""))) {
+                addRef(acc, id, "{% set %}");
+            }
+        }
+        if (node.inline)
+            collectInline(node.inline, acc);
+        if (node.children)
+            collectBlocks(node.children, acc);
+    }
+}
+async function mdFiles(dir) {
+    const out = [];
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules")
+            continue;
+        const full = join(dir, entry.name);
+        if (entry.isDirectory())
+            out.push(...(await mdFiles(full)));
+        else if (entry.name.endsWith(".md"))
+            out.push(full);
+    }
+    return out;
+}
+/** hyphen/underscore-insensitive (the preprocessor runs hyphenToUnderscore). */
+const canon = (s) => s.replace(/-/g, "_");
+export async function auditDeliverableVariables(options) {
+    const known = new Set(Object.keys(options.attributes).map(canon));
+    const issues = [];
+    for (const dir of options.contentDirs) {
+        for (const file of await mdFiles(dir)) {
+            const source = await readFile(file, "utf8").catch(() => null);
+            if (source === null)
+                continue;
+            const acc = { refs: new Map(), defined: new Set() };
+            try {
+                const { tree } = dogsbayMdToTree(source, { directives: "preserve" });
+                collectBlocks(tree, acc);
+            }
+            catch {
+                continue; // unparseable file — other rules own that problem
+            }
+            for (const [id, kinds] of acc.refs) {
+                if (known.has(canon(id)))
+                    continue;
+                if ([...acc.defined].some((d) => canon(d) === canon(id)))
+                    continue;
+                issues.push({
+                    ruleId: "directives/undefined-variable",
+                    severity: "warning",
+                    file: relative(options.siteRoot, file),
+                    message: `"${id}" (used in ${[...kinds].join(", ")}) is not defined by ` +
+                        `deliverable "${options.deliverable}" — the terminal build treats ` +
+                        `undefined conditions as falsy, so guarded content is silently dropped.`,
+                });
+            }
+        }
+    }
+    return issues;
+}

package/dist/audit/dist/crawler.d.ts

@@ -0,0 +1,23 @@
+import type { ParsedHtmlFile } from "../types.js";
+export interface CrawlOptions {
+    /**
+     * File extension to include. Default: `["html", "htm"]`.
+     * Excluded files are silently skipped — Pagefind's prebuilt
+     * JS bundles, sitemap.xml, robots.txt, OG images, etc. don't
+     * need to be parsed for HTML rules.
+     */
+    extensions?: string[];
+    /**
+     * Sub-paths to skip (relative to the dist root). Default
+     * skips Pagefind's runtime + the `_astro/` build-asset bucket
+     * Astro emits — they're not pages, parsing them is wasted
+     * work and produces noisy issues.
+     */
+    excludeDirs?: string[];
+}
+/**
+ * Walk `distRoot` recursively, parse every HTML file with
+ * cheerio, return the list. The list is sorted by path for
+ * deterministic test output.
+ */
+export declare function crawlDist(distRoot: string, options?: CrawlOptions): ParsedHtmlFile[];

package/dist/audit/lib/collect-assets.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Return the set of absolute asset paths (leading slash) that
+ * `copyAssets` would emit for the given content directories.
+ *
+ * @param contentDirs Absolute paths, one per source.
+ */
+export declare function collectAssets(contentDirs: readonly string[]): Set<string>;

package/dist/audit/lib/collect-assets.js

@@ -0,0 +1,64 @@
+/**
+ * Walk one or more content directories collecting absolute-path
+ * asset references that the build's `copyAssets` would emit to
+ * `public/`. The audit rule `structure/asset-refs` cross-checks
+ * `<img src>` / `<a href>` references against this set so a
+ * misnamed file shows up as a structured Issue.
+ *
+ * Mirrors the extension set used by `copyAssets` in
+ * `@dogsbay/format-astro/src/project.ts`. Keep in sync — drift
+ * would either flag valid refs as broken or miss real misses.
+ */
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+// Same sets as format-astro's copyAssets. Keep in sync.
+const OPTIMIZABLE_EXTS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp"]);
+const PASSTHROUGH_EXTS = new Set([".svg", ".ico", ".pdf"]);
+/**
+ * Return the set of absolute asset paths (leading slash) that
+ * `copyAssets` would emit for the given content directories.
+ *
+ * @param contentDirs Absolute paths, one per source.
+ */
+export function collectAssets(contentDirs) {
+    const out = new Set();
+    for (const dir of contentDirs) {
+        if (!existsSync(dir))
+            continue;
+        walk(dir, dir, out);
+    }
+    return out;
+}
+function walk(rootDir, dir, out) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry);
+        let isDir = false;
+        try {
+            isDir = statSync(full).isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (isDir) {
+            walk(rootDir, full, out);
+            continue;
+        }
+        const dot = entry.lastIndexOf(".");
+        if (dot < 0)
+            continue;
+        const ext = entry.slice(dot).toLowerCase();
+        if (!OPTIMIZABLE_EXTS.has(ext) && !PASSTHROUGH_EXTS.has(ext))
+            continue;
+        const rel = relative(rootDir, full);
+        // Public URL is "/<rel>" with forward slashes — copyAssets
+        // copies rel-to-source verbatim into public/.
+        out.add("/" + rel.replace(/\\/g, "/"));
+    }
+}

package/dist/audit/lib/validate-refs.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Pure validator for internal page links + asset references in
+ * imported content. Walks every `ExportPage`'s tree, collects
+ * every absolute `<a href>` and `<img src>`, set-checks against
+ * the page slug set + the asset file set.
+ *
+ * Single source of truth shared between two surfaces:
+ *   - `structure/internal-links` + `structure/asset-refs` audit
+ *     rules (warning-or-error issues from `dogsbay site check`)
+ *   - `dogsbay site build --strict` (throws on first miss)
+ *
+ * See plans/audit-internal-refs.md.
+ */
+import type { ExportPage } from "@dogsbay/types";
+/** One miss found by the validator. */
+export interface RefIssue {
+    /** Slug of the page that contains the broken reference. */
+    pageSlug: string;
+    /** Raw href / src as written by the author. */
+    href: string;
+    /** Whether the validator was looking for a page or an asset. */
+    resolvedAgainst: "page" | "asset";
+}
+export interface ValidateRefsOptions {
+    /** Site basePath (e.g. "/docs", "/" for host-root, "" for root). */
+    basePath: string;
+    /**
+     * Absolute paths under the public asset tree, leading slash,
+     * matching how authors write them. e.g. `"/_assets/foo.png"`.
+     */
+    knownAssets: Set<string>;
+}
+export interface ValidateRefsResult {
+    linkMisses: RefIssue[];
+    assetMisses: RefIssue[];
+}
+export declare function validateRefs(pages: ExportPage[], options: ValidateRefsOptions): ValidateRefsResult;

package/dist/audit/lib/validate-refs.js

@@ -0,0 +1,132 @@
+const EXTERNAL_RE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+const ANCHOR_ONLY_RE = /^#/;
+const DATA_URI_RE = /^data:/i;
+const ASSET_EXT_RE = /\.(png|jpe?g|gif|webp|svg|avif|pdf|zip|csv|tsv|json|yml|yaml|toml|mp4|webm|mp3|ogg|woff2?|ttf|otf)$/i;
+/**
+ * Heuristic for "looks like an asset reference," used to decide
+ * whether an `<a href>` should be validated against the asset
+ * set or the page set. Image src is always asset; href can be
+ * either. Anything ending in a known asset extension is treated
+ * as asset.
+ */
+function looksLikeAsset(href) {
+    // Strip query + fragment before checking extension
+    const noFragment = href.split(/[?#]/)[0];
+    return ASSET_EXT_RE.test(noFragment);
+}
+export function validateRefs(pages, options) {
+    const basePath = options.basePath.replace(/\/$/, "");
+    const knownAssets = options.knownAssets;
+    // Page slug set — multiple match forms so the validator
+    // accepts the common ways authors write the same slug.
+    // For slug "tutorials/quickstart" any of these match:
+    //   /tutorials/quickstart
+    //   /tutorials/quickstart/
+    //   /tutorials/quickstart.md
+    //   /<basePath>/tutorials/quickstart   (and the above three)
+    const pageSlugs = new Set();
+    for (const p of pages) {
+        pageSlugs.add(p.slug);
+        // Index pages can be referenced as their parent dir
+        if (p.slug === "index")
+            pageSlugs.add("");
+        if (p.slug.endsWith("/index")) {
+            pageSlugs.add(p.slug.slice(0, -"/index".length));
+        }
+    }
+    const result = { linkMisses: [], assetMisses: [] };
+    for (const page of pages) {
+        walkTree(page.tree, (href, kind) => {
+            check(href, kind, page.slug, basePath, pageSlugs, knownAssets, result);
+        });
+    }
+    return result;
+}
+/** Internal walk — invokes `visit` for every href/src in the tree. */
+function walkTree(nodes, visit) {
+    for (const node of nodes) {
+        if (node.inline)
+            walkInline(node.inline, visit);
+        if (node.html)
+            walkHtml(node.html, visit);
+        if (node.props?.href && typeof node.props.href === "string") {
+            visit(node.props.href, "link");
+        }
+        if (node.props?.src && typeof node.props.src === "string") {
+            visit(node.props.src, "image");
+        }
+        if (node.children)
+            walkTree(node.children, visit);
+    }
+}
+function walkInline(nodes, visit) {
+    for (const node of nodes) {
+        if (node.type === "link" && typeof node.href === "string") {
+            visit(node.href, "link");
+            if (node.children)
+                walkInline(node.children, visit);
+        }
+        else if (node.type === "image" && typeof node.src === "string") {
+            visit(node.src, "image");
+        }
+        else if (node.type === "highlight" && node.children) {
+            walkInline(node.children, visit);
+        }
+    }
+}
+function walkHtml(html, visit) {
+    // Pre-rendered HTML in `node.html` (Starlight importer output,
+    // MkDocs raw HTML, etc.) — scan with regexes. Cheap; the audit
+    // doesn't need a full HTML parser for this.
+    const aRe = /<a\b[^>]*\shref="([^"]+)"/gi;
+    let m;
+    while ((m = aRe.exec(html)) !== null)
+        visit(m[1], "link");
+    const imgRe = /<img\b[^>]*\ssrc="([^"]+)"/gi;
+    while ((m = imgRe.exec(html)) !== null)
+        visit(m[1], "image");
+}
+function check(href, kind, pageSlug, basePath, pageSlugs, knownAssets, result) {
+    if (!href || EXTERNAL_RE.test(href))
+        return;
+    if (ANCHOR_ONLY_RE.test(href))
+        return;
+    if (DATA_URI_RE.test(href))
+        return;
+    if (!href.startsWith("/"))
+        return; // relative — out of scope for v1
+    // Strip query and fragment for the comparison.
+    const cleanHref = href.split(/[?#]/)[0];
+    // Strip basePath if the author prefixed it. We compare against
+    // bare slugs, so `/docs/intro` and `/intro` should both match
+    // page slug "intro" (basePath="/docs").
+    let path = cleanHref;
+    if (basePath && (path === basePath || path.startsWith(`${basePath}/`))) {
+        path = path.slice(basePath.length);
+    }
+    // Strip leading / and trailing /, plus the `.md` extension.
+    let trimmed = path.replace(/^\//, "").replace(/\/$/, "");
+    trimmed = trimmed.replace(/\.md$/i, "");
+    // Image src — always asset.
+    // Anchor href — asset if it has an asset extension, else page.
+    const wantsAsset = kind === "image" || looksLikeAsset(cleanHref);
+    if (wantsAsset) {
+        // Asset paths are absolute under the public root.
+        // knownAssets stores entries like "/_assets/foo.png".
+        const lookup = cleanHref.startsWith("/") && basePath && cleanHref.startsWith(`${basePath}/`)
+            ? cleanHref.slice(basePath.length)
+            : cleanHref;
+        if (!knownAssets.has(lookup)) {
+            result.assetMisses.push({
+                pageSlug,
+                href,
+                resolvedAgainst: "asset",
+            });
+        }
+        return;
+    }
+    // Page lookup
+    if (!pageSlugs.has(trimmed)) {
+        result.linkMisses.push({ pageSlug, href, resolvedAgainst: "page" });
+    }
+}

package/dist/audit/output/json.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Machine-readable formatter — emits the full report as JSON.
+ * Stable shape for CI consumers; mirrors the `AuditReport` type
+ * exactly with no transformations.
+ */
+import type { AuditReport } from "../types.js";
+export declare function formatJson(report: AuditReport): string;

package/dist/audit/output/text.d.ts

@@ -0,0 +1,6 @@
+import type { AuditReport } from "../types.js";
+export interface FormatTextOptions {
+    /** Force colour off (e.g. for tests). Defaults to TTY detection. */
+    color?: boolean;
+}
+export declare function formatText(report: AuditReport, options?: FormatTextOptions): string;

package/dist/audit/registry.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Rule registry — the global list of audit rules + helpers for
+ * filtering by category, id pattern, or skip list.
+ *
+ * Categories register their rules at module-load time via
+ * `registerRule` (typically inside a category's `index.ts`,
+ * imported by the audit runner). The registry is keyed by
+ * `Rule.id` so duplicate registrations are caught early.
+ *
+ * Filtering supports category aliases (`seo`, `links`, …) and
+ * glob-style ids (`seo/<name>`, `<cat>/description-<name>`) so
+ * the CLI surface can be expressive without each rule needing
+ * its own flag. Glob is wildcard-only; see `compileGlob` for
+ * the supported pattern grammar.
+ */
+import type { Rule, Stage } from "./types.js";
+/**
+ * Register a rule. Throws on duplicate id — rule files import
+ * each other only via the index, and double-registration
+ * indicates a copy-paste bug.
+ */
+export declare function registerRule(rule: Rule): void;
+/** All registered rules, in registration order. */
+export declare function listRules(): Rule[];
+/** Lookup by exact id, or `undefined` if unknown. */
+export declare function getRule(id: string): Rule | undefined;
+/** Test-only: clear the registry between tests. Internal use. */
+export declare function _clearRegistry(): void;
+export interface FilterOptions {
+    /**
+     * Subset of categories to include. When non-empty, rules whose
+     * `category` is not in this list are dropped. Empty / undefined
+     * means "all categories."
+     */
+    categories?: string[];
+    /**
+     * Subset of stages to include. Same semantics as `categories`.
+     */
+    stages?: Stage[];
+    /**
+     * Explicit rule list — id strings, optionally with `*` glob.
+     * When set, ONLY rules matching one of these patterns run.
+     * Takes precedence over `categories` / `stages`.
+     */
+    rules?: string[];
+    /** Patterns of rule ids to skip. Applied AFTER inclusion filters. */
+    skip?: string[];
+}
+/**
+ * Apply category / stage / explicit / skip filters. Glob patterns
+ * use `*` to match any run of characters within a single segment
+ * (no recursive descent — pattern grammar is intentionally
+ * simple).
+ */
+export declare function filterRules(options?: FilterOptions, rules?: Rule[]): Rule[];

package/dist/audit/rules/seo/description-length.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Rule: `seo/description-length`
+ *
+ * Flag pages whose `frontmatter.description` exceeds 160
+ * characters. Google truncates SERP snippets at ~155-160 chars
+ * (the "safe zone" called out in the 100daysofdocs SEO audit);
+ * over-length descriptions get cut mid-sentence, leaving readers
+ * with a worse first impression than a shorter, polished version.
+ *
+ * Severity: warning. The page still functions; it just loses
+ * some snippet quality. Writers fix it by shortening or by
+ * setting `description: ""` to suppress.
+ */
+import type { Rule } from "../../types.js";
+export declare const DEFAULT_MAX_DESCRIPTION_LENGTH = 160;
+export declare const descriptionLength: Rule;

package/dist/audit/rules/seo/description-missing.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Rule: `seo/description-missing`
+ *
+ * Flag pages without a frontmatter description. Without one,
+ * Google falls back to whatever it can extract from body prose,
+ * which is often misleading (a navigation chip, a callout title,
+ * the first line of a code block). Authoring a description per
+ * page is the cheapest fix.
+ *
+ * Severity: warning. Doesn't break anything — degrades discovery.
+ *
+ * Skipped for redirect pages: they don't render normal content.
+ */
+import type { Rule } from "../../types.js";
+export declare const descriptionMissing: Rule;

package/dist/audit/rules/seo/dist-meta.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Rule: `seo/dist-meta`
+ *
+ * Walk the rendered HTML and assert the basic SEO meta surface
+ * is populated:
+ *   - `<title>` present and non-empty (error)
+ *   - `<meta name="description">` present and non-empty (warning)
+ *   - `<meta property="og:title">` and `og:description` present (warning)
+ *   - `<meta property="og:type">` set (warning)
+ *
+ * Twitter Card meta is NOT enforced — Twitter has been steadily
+ * deprecating its preview card spec, and og:* covers most cases
+ * since Twitter falls back to OG when its own tags are missing.
+ *
+ * Skipped for redirect pages (we detect them by checking for a
+ * <meta http-equiv="refresh"> or a `<link rel="canonical">` to
+ * a different URL — but for now, we just exclude `index.html`
+ * pages whose body is suspiciously empty). Implementation-wise,
+ * a future `seo/redirect-detection` helper could centralize this.
+ */
+import type { Rule } from "../../types.js";
+export declare const distMeta: Rule;

package/dist/audit/rules/seo/h1-brand-keyword.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../types.js";
+export declare const h1BrandKeyword: Rule;

package/dist/audit/rules/seo/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Idempotent — calling `registerSeoRules` more than once is a
+ * no-op. Lets callers (CLI, tests) register without coordinating.
+ */
+export declare function registerSeoRules(): void;
+/**
+ * Test-only: reset the "registered" flag so unit tests can
+ * register fresh after `_clearRegistry()`. Production code never
+ * calls this.
+ */
+export declare function _resetSeoRegistration(): void;

package/dist/audit/rules/seo/json-ld-parse.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Rule: `seo/json-ld-parse`
+ *
+ * Every `<script type="application/ld+json">` block on the page
+ * must parse as valid JSON. Malformed JSON-LD is invisible to
+ * Google Search and accidentally introduces invalid output that
+ * the Rich Results validator rejects.
+ *
+ * Severity: error. Broken JSON-LD = wasted machine-readable
+ * markup; this is a real bug worth blocking a build on.
+ */
+import type { Rule } from "../../types.js";
+export declare const jsonLdParse: Rule;

package/dist/audit/rules/seo/json-ld-required-fields.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Rule: `seo/json-ld-required-fields`
+ *
+ * For each well-formed JSON-LD block on the page, validate that
+ * the declared `@type` carries the fields Google expects for
+ * Rich Results eligibility. Catches the common case where a
+ * writer extends `customJsonLd` with a Course block but omits
+ * `provider`, or where DocsLayout's auto-emit drops a required
+ * field on a particular page.
+ *
+ * We don't bundle the full Schema.org vocabulary — just the
+ * @type values DocsLayout emits (Article, HowTo, TechArticle,
+ * Course) plus a few common extension types (Person,
+ * Organization, BreadcrumbList).
+ *
+ * Companion to `seo/json-ld-parse`: parse fires on malformed
+ * JSON; this fires on well-formed JSON that's missing
+ * Rich-Results-required fields.
+ */
+import type { Rule } from "../../types.js";
+export declare const jsonLdRequiredFields: Rule;

package/dist/audit/rules/seo/keyword-placement.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../types.js";
+export declare const keywordPlacement: Rule;

package/dist/audit/rules/seo/sitemap.d.ts

@@ -0,0 +1,5 @@
+import type { Rule } from "../../types.js";
+export declare function _resetSitemapCache(): void;
+export declare const sitemapPresent: Rule;
+export declare const sitemapComplete: Rule;
+export declare const sitemapRobotsCoherence: Rule;