@relvehq/agent-ready 0.0.0-stage → 0.2.1

package/dist/core/resolve.js

@@ -0,0 +1,204 @@
+"use strict";
+// Resolve: find the Markdown for a page.
+//
+//   native   config.templates, first matching route pattern ("/tool/:slug")
+//   stored   config.store.get(path)
+//   convert  fetch the page's own HTML from the origin and convert it
+//   null     nothing usable; the caller serves HTML (or a 404 for `.md` URLs)
+//
+// Each step that throws or returns nothing falls through to the next one.
+// The origin fetch sends `Accept: text/html` and the internal header, so the
+// middleware adapter never intercepts it, and sends no cookies, so the
+// Markdown is always the public page.
+//
+// NODE ONLY when the convert step runs (it loads ./convert lazily).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveMarkdown = resolveMarkdown;
+exports.defaultFetchOrigin = defaultFetchOrigin;
+exports.matchPattern = matchPattern;
+const config_1 = require("./config");
+const MAX_HTML_BYTES = 5 * 1024 * 1024;
+async function resolveMarkdown(cfg, input, deps = {}) {
+    const { path, search, request } = input;
+    const pageUrl = cfg.site + (path === "/" ? "/" : path) + search;
+    const miss = { source: null, doc: null, sourceUrl: pageUrl, html: null, originStatus: null };
+    const found = (source, doc) => ({
+        source,
+        doc,
+        sourceUrl: pageUrl,
+        html: null,
+        originStatus: null,
+    });
+    if ((0, config_1.isExcluded)(cfg, path))
+        return miss;
+    // 1. native
+    for (const [pattern, fn] of Object.entries(cfg.templates)) {
+        const params = matchPattern(pattern, path);
+        if (!params)
+            continue;
+        const doc = await safely(`template ${pattern}`, () => fn({ path, params, search, request }));
+        if (doc)
+            return found("native", doc);
+        break; // only the first matching pattern is tried
+    }
+    // 2. stored
+    if (cfg.store) {
+        const store = cfg.store;
+        const doc = await safely("store", () => store.get(path, { request }));
+        if (doc)
+            return found("stored", doc);
+    }
+    // 3. convert
+    if (cfg.fallback !== "convert")
+        return miss;
+    const origin = (cfg.fetchOrigin ? cfg.fetchOrigin(request) : defaultFetchOrigin(request, cfg.site)).replace(/\/+$/, "");
+    const fetchUrl = origin + (path === "/" ? "/" : path) + search;
+    const doFetch = deps.fetch ?? fetch;
+    let res;
+    try {
+        res = await doFetch(fetchUrl, {
+            method: "GET",
+            redirect: "follow",
+            cache: "no-store",
+            headers: {
+                accept: "text/html",
+                [cfg.internalHeader]: "1",
+                "user-agent": "agent-ready/0.1 (+internal origin fetch)",
+            },
+            signal: timeoutSignal(cfg.fetchTimeoutMs),
+        });
+    }
+    catch (err) {
+        console.warn(`[agent-ready] origin fetch failed for ${path}: ${err?.message ?? err}`);
+        return miss;
+    }
+    const contentType = res.headers.get("content-type") ?? "";
+    const declared = Number(res.headers.get("content-length") ?? "0");
+    if (declared > MAX_HTML_BYTES)
+        return { ...miss, originStatus: res.status };
+    const body = await res.text().catch(() => "");
+    const html = { status: res.status, contentType: contentType || "text/html; charset=utf-8", body };
+    if (!res.ok || !/text\/html|application\/xhtml/i.test(contentType) || body.length > MAX_HTML_BYTES) {
+        return { ...miss, html, originStatus: res.status };
+    }
+    const convert = deps.convert ?? (await Promise.resolve().then(() => __importStar(require("./convert")))).htmlToMarkdown;
+    let converted = null;
+    try {
+        converted = convert(body, { url: pageUrl, minChars: cfg.minChars });
+    }
+    catch (err) {
+        console.warn(`[agent-ready] convert failed for ${path}: ${err?.message ?? err}`);
+    }
+    if (!converted)
+        return { ...miss, html, originStatus: res.status };
+    return found("convert", converted);
+}
+/**
+ * Where the converter fetches HTML from: the host the request came in on, so
+ * staging converts staging and a test host converts itself. `*.localhost`
+ * names become `localhost` (Node's resolver doesn't map them everywhere).
+ */
+function defaultFetchOrigin(request, site) {
+    const h = request.headers;
+    const host = (h.get("x-forwarded-host") ?? h.get("host") ?? "").split(",")[0].trim();
+    let reqUrl = null;
+    try {
+        reqUrl = new URL(request.url);
+    }
+    catch {
+        // fall through to site
+    }
+    if (!host)
+        return reqUrl ? reqUrl.origin : site;
+    const proto = (h.get("x-forwarded-proto") ?? "").split(",")[0].trim() ||
+        (reqUrl ? reqUrl.protocol.replace(":", "") : "https");
+    const [name, port] = host.split(":");
+    const hostname = name.toLowerCase().endsWith(".localhost") ? "localhost" : name;
+    return `${proto}://${hostname}${port ? `:${port}` : ""}`;
+}
+/**
+ * "/tool/:slug" -> { slug }, "/docs/*" -> { "*": rest }. Exact otherwise.
+ * Returns null when the path doesn't match.
+ */
+function matchPattern(pattern, path) {
+    const p = pattern.replace(/\/+$/, "") || "/";
+    const pp = p.split("/").filter(Boolean);
+    const xs = path.split("/").filter(Boolean);
+    const params = {};
+    for (let i = 0; i < pp.length; i++) {
+        const seg = pp[i];
+        if (seg === "*" && i === pp.length - 1) {
+            if (i >= xs.length)
+                return null;
+            params["*"] = xs.slice(i).join("/");
+            return params;
+        }
+        if (i >= xs.length)
+            return null;
+        if (seg.startsWith(":")) {
+            try {
+                params[seg.slice(1)] = decodeURIComponent(xs[i]);
+            }
+            catch {
+                return null;
+            }
+        }
+        else if (seg !== xs[i]) {
+            return null;
+        }
+    }
+    return pp.length === xs.length ? params : null;
+}
+function normalizeDoc(r) {
+    if (!r)
+        return null;
+    if (typeof r === "string")
+        return r.trim() ? { markdown: r } : null;
+    return r.markdown && r.markdown.trim() ? r : null;
+}
+async function safely(label, fn) {
+    try {
+        return normalizeDoc((await fn()));
+    }
+    catch (err) {
+        console.warn(`[agent-ready] ${label} failed: ${err?.message ?? err}`);
+        return null;
+    }
+}
+function timeoutSignal(ms) {
+    const AS = AbortSignal;
+    return typeof AS.timeout === "function" ? AS.timeout(ms) : undefined;
+}

package/dist/core/respond.d.ts

@@ -0,0 +1,18 @@
+export interface RespondOptions {
+    request: Request;
+    /** Absolute canonical URL of the HTML page. */
+    canonical: string;
+    tokens: number;
+    cacheControl: string;
+    status?: number;
+    contentType?: string;
+    /** Extra headers, e.g. { "x-agent-ready-source": "convert" }. */
+    headers?: Record<string, string>;
+}
+export declare const MARKDOWN_CONTENT_TYPE = "text/markdown; charset=utf-8";
+export declare function markdownResponse(body: string, opts: RespondOptions): Promise<Response>;
+/** A strong ETag: the first 32 hex chars of SHA-256(body). */
+export declare function etagFor(body: string): Promise<string>;
+/** RFC 9110 §13.1.2: weak comparison; `*` matches any current representation. */
+export declare function ifNoneMatchHits(header: string | null, etag: string): boolean;
+export declare function byteLength(s: string): number;

package/dist/core/respond.js

@@ -0,0 +1,59 @@
+"use strict";
+// Respond: turn a Markdown body into a standard Web Response.
+//
+// Headers: Content-Type text/markdown, Vary: Accept, Link rel=canonical,
+// X-Robots-Tag: noindex (the HTML page is the indexable one), x-markdown-tokens,
+// Cache-Control and a strong ETag. If-None-Match is honoured with a 304.
+//
+// EDGE-SAFE. Uses Web Crypto only.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MARKDOWN_CONTENT_TYPE = void 0;
+exports.markdownResponse = markdownResponse;
+exports.etagFor = etagFor;
+exports.ifNoneMatchHits = ifNoneMatchHits;
+exports.byteLength = byteLength;
+exports.MARKDOWN_CONTENT_TYPE = "text/markdown; charset=utf-8";
+async function markdownResponse(body, opts) {
+    // The front matter's generated_at changes on every conversion, so hashing it
+    // gave every request a new ETag and 304s never happened (seen in the
+    // fresh-app test, 2026-10-21). Hash the content without that line; the
+    // bytes can still differ by the timestamp, so the ETag is weak (W/).
+    const stable = body.replace(/^generated_at:.*\n?/m, "");
+    const etag = stable === body ? await etagFor(body) : `W/${await etagFor(stable)}`;
+    const headers = new Headers({
+        "content-type": opts.contentType ?? exports.MARKDOWN_CONTENT_TYPE,
+        vary: "Accept",
+        link: `<${opts.canonical}>; rel="canonical"`,
+        "x-robots-tag": "noindex",
+        "x-markdown-tokens": String(opts.tokens),
+        "cache-control": opts.cacheControl,
+        etag,
+        ...(opts.headers ?? {}),
+    });
+    if (ifNoneMatchHits(opts.request.headers.get("if-none-match"), etag)) {
+        headers.delete("content-type");
+        return new Response(null, { status: 304, headers });
+    }
+    const isHead = opts.request.method === "HEAD";
+    headers.set("content-length", String(byteLength(body)));
+    return new Response(isHead ? null : body, { status: opts.status ?? 200, headers });
+}
+/** A strong ETag: the first 32 hex chars of SHA-256(body). */
+async function etagFor(body) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(body));
+    const hex = Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+    return `"${hex.slice(0, 32)}"`;
+}
+/** RFC 9110 §13.1.2: weak comparison; `*` matches any current representation. */
+function ifNoneMatchHits(header, etag) {
+    if (!header)
+        return false;
+    const bare = etag.replace(/^W\//, "");
+    return header.split(",").some((raw) => {
+        const t = raw.trim();
+        return t === "*" || t.replace(/^W\//, "") === bare;
+    });
+}
+function byteLength(s) {
+    return new TextEncoder().encode(s).length;
+}

package/dist/core/sitemap.d.ts

@@ -0,0 +1,31 @@
+import type { LlmsEntry } from "./config";
+export interface ParsedSitemap {
+    /** Page URLs from a <urlset>. */
+    urls: string[];
+    /** Child sitemap URLs from a <sitemapindex>. */
+    sitemaps: string[];
+}
+/** Parse a sitemap or sitemap index. Tolerant: unknown markup is ignored. */
+export declare function parseSitemap(xml: string): ParsedSitemap;
+export interface SitemapEntriesOptions {
+    /** Sitemap location. Default "/sitemap.xml" on the request's origin. */
+    path?: string;
+    /** Most pages listed. Default 200. */
+    limit?: number;
+    /** Child sitemaps followed from an index. Default 5. */
+    maxSitemaps?: number;
+    /** Paths (segment-aware prefixes) or RegExps left out. */
+    exclude?: Array<string | RegExp>;
+    /** Fetch timeout per sitemap. Default 5000 ms. */
+    timeoutMs?: number;
+    /** Injected for tests. */
+    fetch?: typeof fetch;
+}
+/** An `llms.entries` function that reads the site's sitemap. */
+export declare function sitemapEntries(opts?: SitemapEntriesOptions): (ctx: {
+    request: Request;
+}) => Promise<LlmsEntry[]>;
+/** Turn page URLs into llms entries (exported for tests and custom sources). */
+export declare function entriesFromUrls(urls: string[], origin: string, opts?: Pick<SitemapEntriesOptions, "limit" | "exclude">): LlmsEntry[];
+/** "ai-tools_list" -> "Ai tools list". */
+export declare function humanize(seg: string): string;

package/dist/core/sitemap.js

@@ -0,0 +1,140 @@
+"use strict";
+// Discover, the easy way: llms.txt entries from the site's own sitemap.xml,
+// so a venture lists nothing by hand (changes/agent-ready-engine, "easy setup").
+//
+//   llms: { title: "Acme", entries: sitemapEntries() }
+//
+// Reads /sitemap.xml (following a sitemap index one level down), keeps
+// same-site page URLs, and turns each into an entry: a title from the last
+// path segment ("/pricing/teams" -> "Teams"), a section from the first one
+// ("Pricing"; the home page goes under "Pages"). Capped, de-duplicated,
+// sorted by section then path. Any failure -> no entries, never a throw.
+//
+// EDGE-SAFE. No Node APIs (regex parsing, global fetch).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSitemap = parseSitemap;
+exports.sitemapEntries = sitemapEntries;
+exports.entriesFromUrls = entriesFromUrls;
+exports.humanize = humanize;
+/** Parse a sitemap or sitemap index. Tolerant: unknown markup is ignored. */
+function parseSitemap(xml) {
+    const locs = (block) => Array.from(block.matchAll(/<loc>\s*(?:<!\[CDATA\[)?\s*([^<\]]+?)\s*(?:\]\]>)?\s*<\/loc>/gi), (m) => decodeXml(m[1]));
+    if (/<sitemapindex[\s>]/i.test(xml)) {
+        const sitemaps = Array.from(xml.matchAll(/<sitemap[\s>][\s\S]*?<\/sitemap>/gi)).flatMap((m) => locs(m[0]));
+        return { urls: [], sitemaps };
+    }
+    const urls = Array.from(xml.matchAll(/<url[\s>][\s\S]*?<\/url>/gi)).flatMap((m) => locs(m[0]));
+    return { urls, sitemaps: [] };
+}
+/** An `llms.entries` function that reads the site's sitemap. */
+function sitemapEntries(opts = {}) {
+    return async ({ request }) => {
+        try {
+            const origin = new URL(request.url).origin;
+            const urls = await collectUrls(new URL(opts.path ?? "/sitemap.xml", origin).href, origin, opts);
+            return entriesFromUrls(urls, origin, opts);
+        }
+        catch {
+            return [];
+        }
+    };
+}
+/** Turn page URLs into llms entries (exported for tests and custom sources). */
+function entriesFromUrls(urls, origin, opts = {}) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of urls) {
+        let u;
+        try {
+            u = new URL(raw, origin);
+        }
+        catch {
+            continue;
+        }
+        // Only the path is kept: a sitemap names the production host, and the
+        // entries are linked on whatever site serves this llms.txt.
+        const path = (u.pathname.replace(/\/+$/, "") || "/").replace(/\.html?$/i, "");
+        if (/\.(xml|txt|json|pdf|jpe?g|png|gif|svg|webp|zip)$/i.test(path))
+            continue;
+        if (isOut(path, opts.exclude))
+            continue;
+        if (seen.has(path))
+            continue;
+        seen.add(path);
+        const segs = path.split("/").filter(Boolean).map(safeDecode);
+        out.push({
+            path,
+            url: path,
+            title: segs.length ? humanize(segs[segs.length - 1]) : "Home",
+            section: segs.length > 1 ? humanize(segs[0]) : "Pages",
+        });
+        if (out.length >= (opts.limit ?? 200))
+            break;
+    }
+    out.sort((a, b) => (a.section === b.section ? a.path.localeCompare(b.path) : a.section === "Pages" ? -1 : b.section === "Pages" ? 1 : a.section.localeCompare(b.section)));
+    return out.map(({ path: _path, ...e }) => e);
+}
+async function collectUrls(start, origin, opts) {
+    const first = await fetchSitemap(start, opts);
+    if (!first)
+        return [];
+    if (!first.sitemaps.length)
+        return first.urls;
+    const children = first.sitemaps.slice(0, opts.maxSitemaps ?? 5).map((s) => {
+        // Child sitemaps on the production host are read from this origin instead.
+        try {
+            const u = new URL(s, origin);
+            return new URL(u.pathname + u.search, origin).href;
+        }
+        catch {
+            return null;
+        }
+    });
+    const lists = await Promise.all(children.filter((c) => !!c).map((c) => fetchSitemap(c, opts)));
+    return lists.flatMap((l) => (l ? l.urls : []));
+}
+async function fetchSitemap(url, opts) {
+    const f = opts.fetch ?? fetch;
+    const ctl = new AbortController();
+    const timer = setTimeout(() => ctl.abort(), opts.timeoutMs ?? 5000);
+    try {
+        const res = await f(url, { signal: ctl.signal, headers: { accept: "application/xml,text/xml;q=0.9,*/*;q=0.1" } });
+        if (!res.ok)
+            return null;
+        return parseSitemap(await res.text());
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function isOut(path, exclude) {
+    for (const rule of exclude ?? []) {
+        if (typeof rule === "string") {
+            const p = rule.replace(/\/+$/, "");
+            if (p && (path === p || path.startsWith(p + "/")))
+                return true;
+        }
+        else if (rule.test(path))
+            return true;
+    }
+    return false;
+}
+/** "ai-tools_list" -> "Ai tools list". */
+function humanize(seg) {
+    const s = seg.replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim();
+    return s ? s.charAt(0).toUpperCase() + s.slice(1) : seg;
+}
+function safeDecode(s) {
+    try {
+        return decodeURIComponent(s);
+    }
+    catch {
+        return s;
+    }
+}
+function decodeXml(s) {
+    return s.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'");
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { chooseFormat, parseAccept, type Format, type MediaRange } from "./core/accept";
+export { ALWAYS_EXCLUDE, DEFAULT_CACHE_CONTROL, DEFAULT_INTERNAL_HEADER, DEFAULT_INTERNAL_PREFIX, DEFAULT_NEGOTIATED_CACHE_CONTROL, VIA_HEADER, defineAgentReady, emitHit, isEnabled, isExcluded, type AgentReadyConfig, type Awaitable, type DocResult, type HitEvent, type LlmsConfig, type LlmsEntry, type MarkdownDoc, type MarkdownStore, type ResolvedAgentReadyConfig, type Source, type TemplateContext, type TemplateFn, type Via, } from "./core/config";
+export { mdUrlPath, normalizePath, stripMdSuffix, wantsMarkdown, type Detection, type RequestLike } from "./core/detect";
+export { enrich, estimateTokens, frontMatter, hasFrontMatter, jsonLdFacts, type EnrichMeta, type Enriched } from "./core/enrich";
+export { buildLlmsTxt, type BuildLlmsOptions } from "./core/llms";
+export { byteLength, etagFor, ifNoneMatchHits, markdownResponse, MARKDOWN_CONTENT_TYPE, type RespondOptions } from "./core/respond";
+export { COMMON_PRIVATE_PATHS, createAgentReady, enabledFromEnv, siteFromEnv, type EasyOptions, type Env } from "./core/easy";
+export { entriesFromUrls, humanize, parseSitemap, sitemapEntries, type ParsedSitemap, type SitemapEntriesOptions } from "./core/sitemap";
+export { reporter, reporterFromEnv, type ReporterOptions } from "./core/report";
+export { ANSWER_BOT_TOKENS, classifyAgent, isAnswerBot, type Bot, type BotKind } from "./proof/bots";
+export { filterHits, memoryHitStore, teeHits, type HitQuery, type HitStore } from "./proof/hits";
+export { formatSummary, summarize, type Count, type HitSummary } from "./proof/stats";
+export { renderDashboard, type DashboardOptions } from "./proof/dashboard";
+export { auditSite, blockedBots, formatAudit, type AuditCheck, type AuditOptions, type AuditReport, type CheckStatus } from "./proof/audit";

package/dist/index.js

@@ -0,0 +1,76 @@
+"use strict";
+// @relvehq/agent-ready: serve a clean Markdown version of any page to AI agents.
+//
+// This barrel is EDGE-SAFE: it exports only modules with no Node APIs, so it
+// can be imported from middleware. The Node-only parts are imported by path:
+//   @relvehq/agent-ready/core/convert   HTML -> Markdown (linkedom, turndown)
+//   @relvehq/agent-ready/core/resolve   native -> stored -> convert chain
+//   @relvehq/agent-ready/next/route     Next.js route handler
+// and the Next.js middleware adapter lives at @relvehq/agent-ready/next.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAudit = exports.blockedBots = exports.auditSite = exports.renderDashboard = exports.summarize = exports.formatSummary = exports.teeHits = exports.memoryHitStore = exports.filterHits = exports.isAnswerBot = exports.classifyAgent = exports.ANSWER_BOT_TOKENS = exports.reporterFromEnv = exports.reporter = exports.sitemapEntries = exports.parseSitemap = exports.humanize = exports.entriesFromUrls = exports.siteFromEnv = exports.enabledFromEnv = exports.createAgentReady = exports.COMMON_PRIVATE_PATHS = exports.MARKDOWN_CONTENT_TYPE = exports.markdownResponse = exports.ifNoneMatchHits = exports.etagFor = exports.byteLength = exports.buildLlmsTxt = exports.jsonLdFacts = exports.hasFrontMatter = exports.frontMatter = exports.estimateTokens = exports.enrich = exports.wantsMarkdown = exports.stripMdSuffix = exports.normalizePath = exports.mdUrlPath = exports.isExcluded = exports.isEnabled = exports.emitHit = exports.defineAgentReady = exports.VIA_HEADER = exports.DEFAULT_NEGOTIATED_CACHE_CONTROL = exports.DEFAULT_INTERNAL_PREFIX = exports.DEFAULT_INTERNAL_HEADER = exports.DEFAULT_CACHE_CONTROL = exports.ALWAYS_EXCLUDE = exports.parseAccept = exports.chooseFormat = void 0;
+var accept_1 = require("./core/accept");
+Object.defineProperty(exports, "chooseFormat", { enumerable: true, get: function () { return accept_1.chooseFormat; } });
+Object.defineProperty(exports, "parseAccept", { enumerable: true, get: function () { return accept_1.parseAccept; } });
+var config_1 = require("./core/config");
+Object.defineProperty(exports, "ALWAYS_EXCLUDE", { enumerable: true, get: function () { return config_1.ALWAYS_EXCLUDE; } });
+Object.defineProperty(exports, "DEFAULT_CACHE_CONTROL", { enumerable: true, get: function () { return config_1.DEFAULT_CACHE_CONTROL; } });
+Object.defineProperty(exports, "DEFAULT_INTERNAL_HEADER", { enumerable: true, get: function () { return config_1.DEFAULT_INTERNAL_HEADER; } });
+Object.defineProperty(exports, "DEFAULT_INTERNAL_PREFIX", { enumerable: true, get: function () { return config_1.DEFAULT_INTERNAL_PREFIX; } });
+Object.defineProperty(exports, "DEFAULT_NEGOTIATED_CACHE_CONTROL", { enumerable: true, get: function () { return config_1.DEFAULT_NEGOTIATED_CACHE_CONTROL; } });
+Object.defineProperty(exports, "VIA_HEADER", { enumerable: true, get: function () { return config_1.VIA_HEADER; } });
+Object.defineProperty(exports, "defineAgentReady", { enumerable: true, get: function () { return config_1.defineAgentReady; } });
+Object.defineProperty(exports, "emitHit", { enumerable: true, get: function () { return config_1.emitHit; } });
+Object.defineProperty(exports, "isEnabled", { enumerable: true, get: function () { return config_1.isEnabled; } });
+Object.defineProperty(exports, "isExcluded", { enumerable: true, get: function () { return config_1.isExcluded; } });
+var detect_1 = require("./core/detect");
+Object.defineProperty(exports, "mdUrlPath", { enumerable: true, get: function () { return detect_1.mdUrlPath; } });
+Object.defineProperty(exports, "normalizePath", { enumerable: true, get: function () { return detect_1.normalizePath; } });
+Object.defineProperty(exports, "stripMdSuffix", { enumerable: true, get: function () { return detect_1.stripMdSuffix; } });
+Object.defineProperty(exports, "wantsMarkdown", { enumerable: true, get: function () { return detect_1.wantsMarkdown; } });
+var enrich_1 = require("./core/enrich");
+Object.defineProperty(exports, "enrich", { enumerable: true, get: function () { return enrich_1.enrich; } });
+Object.defineProperty(exports, "estimateTokens", { enumerable: true, get: function () { return enrich_1.estimateTokens; } });
+Object.defineProperty(exports, "frontMatter", { enumerable: true, get: function () { return enrich_1.frontMatter; } });
+Object.defineProperty(exports, "hasFrontMatter", { enumerable: true, get: function () { return enrich_1.hasFrontMatter; } });
+Object.defineProperty(exports, "jsonLdFacts", { enumerable: true, get: function () { return enrich_1.jsonLdFacts; } });
+var llms_1 = require("./core/llms");
+Object.defineProperty(exports, "buildLlmsTxt", { enumerable: true, get: function () { return llms_1.buildLlmsTxt; } });
+var respond_1 = require("./core/respond");
+Object.defineProperty(exports, "byteLength", { enumerable: true, get: function () { return respond_1.byteLength; } });
+Object.defineProperty(exports, "etagFor", { enumerable: true, get: function () { return respond_1.etagFor; } });
+Object.defineProperty(exports, "ifNoneMatchHits", { enumerable: true, get: function () { return respond_1.ifNoneMatchHits; } });
+Object.defineProperty(exports, "markdownResponse", { enumerable: true, get: function () { return respond_1.markdownResponse; } });
+Object.defineProperty(exports, "MARKDOWN_CONTENT_TYPE", { enumerable: true, get: function () { return respond_1.MARKDOWN_CONTENT_TYPE; } });
+// Easy setup: smart defaults, llms.txt from the sitemap, dashboard reporting.
+var easy_1 = require("./core/easy");
+Object.defineProperty(exports, "COMMON_PRIVATE_PATHS", { enumerable: true, get: function () { return easy_1.COMMON_PRIVATE_PATHS; } });
+Object.defineProperty(exports, "createAgentReady", { enumerable: true, get: function () { return easy_1.createAgentReady; } });
+Object.defineProperty(exports, "enabledFromEnv", { enumerable: true, get: function () { return easy_1.enabledFromEnv; } });
+Object.defineProperty(exports, "siteFromEnv", { enumerable: true, get: function () { return easy_1.siteFromEnv; } });
+var sitemap_1 = require("./core/sitemap");
+Object.defineProperty(exports, "entriesFromUrls", { enumerable: true, get: function () { return sitemap_1.entriesFromUrls; } });
+Object.defineProperty(exports, "humanize", { enumerable: true, get: function () { return sitemap_1.humanize; } });
+Object.defineProperty(exports, "parseSitemap", { enumerable: true, get: function () { return sitemap_1.parseSitemap; } });
+Object.defineProperty(exports, "sitemapEntries", { enumerable: true, get: function () { return sitemap_1.sitemapEntries; } });
+var report_1 = require("./core/report");
+Object.defineProperty(exports, "reporter", { enumerable: true, get: function () { return report_1.reporter; } });
+Object.defineProperty(exports, "reporterFromEnv", { enumerable: true, get: function () { return report_1.reporterFromEnv; } });
+// Proof: who reads, how much, and how agent-ready a site is.
+var bots_1 = require("./proof/bots");
+Object.defineProperty(exports, "ANSWER_BOT_TOKENS", { enumerable: true, get: function () { return bots_1.ANSWER_BOT_TOKENS; } });
+Object.defineProperty(exports, "classifyAgent", { enumerable: true, get: function () { return bots_1.classifyAgent; } });
+Object.defineProperty(exports, "isAnswerBot", { enumerable: true, get: function () { return bots_1.isAnswerBot; } });
+var hits_1 = require("./proof/hits");
+Object.defineProperty(exports, "filterHits", { enumerable: true, get: function () { return hits_1.filterHits; } });
+Object.defineProperty(exports, "memoryHitStore", { enumerable: true, get: function () { return hits_1.memoryHitStore; } });
+Object.defineProperty(exports, "teeHits", { enumerable: true, get: function () { return hits_1.teeHits; } });
+var stats_1 = require("./proof/stats");
+Object.defineProperty(exports, "formatSummary", { enumerable: true, get: function () { return stats_1.formatSummary; } });
+Object.defineProperty(exports, "summarize", { enumerable: true, get: function () { return stats_1.summarize; } });
+var dashboard_1 = require("./proof/dashboard");
+Object.defineProperty(exports, "renderDashboard", { enumerable: true, get: function () { return dashboard_1.renderDashboard; } });
+var audit_1 = require("./proof/audit");
+Object.defineProperty(exports, "auditSite", { enumerable: true, get: function () { return audit_1.auditSite; } });
+Object.defineProperty(exports, "blockedBots", { enumerable: true, get: function () { return audit_1.blockedBots; } });
+Object.defineProperty(exports, "formatAudit", { enumerable: true, get: function () { return audit_1.formatAudit; } });

package/dist/next/dashboard.d.ts

@@ -0,0 +1,14 @@
+import type { HitStore } from "../proof/hits";
+export interface DashboardRouteOptions {
+    store: HitStore;
+    /** Shown in the heading. */
+    site: string;
+    /** Access key. Default process.env.AGENT_READY_DASHBOARD_KEY. */
+    key?: string | null;
+    /** Default window in days. Default 30. */
+    days?: number;
+    now?: () => Date;
+}
+export declare function createDashboardRoute(opts: DashboardRouteOptions): {
+    GET: (req: Request) => Promise<Response>;
+};

package/dist/next/dashboard.js

@@ -0,0 +1,56 @@
+"use strict";
+// The dashboard as a Next.js route (Proof). Behind a key; HTML or JSON.
+//
+//   // app/agent-ready-dashboard/route.ts
+//   import { createDashboardRoute } from "@relvehq/agent-ready/next/dashboard";
+//   export const { GET } = createDashboardRoute({ store: hits, site: "acme.com" });
+//   export const dynamic = "force-dynamic";
+//
+//   GET /agent-ready-dashboard?key=…            the page
+//   GET /agent-ready-dashboard?key=…&format=json the summary as JSON
+//   GET /agent-ready-dashboard?days=7           last 7 days (default 30)
+//
+// The key is AGENT_READY_DASHBOARD_KEY (or `key`), sent as `?key=` or
+// `Authorization: Bearer`. No key configured -> 404: a dashboard is never
+// public by accident. EDGE-SAFE (works in either runtime).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDashboardRoute = createDashboardRoute;
+const dashboard_1 = require("../proof/dashboard");
+const stats_1 = require("../proof/stats");
+function createDashboardRoute(opts) {
+    const GET = async (req) => {
+        const key = opts.key !== undefined ? opts.key : typeof process !== "undefined" ? process.env.AGENT_READY_DASHBOARD_KEY ?? null : null;
+        if (!key)
+            return new Response("Not found", { status: 404, headers: { "cache-control": "no-store" } });
+        const url = new URL(req.url);
+        const given = url.searchParams.get("key") ?? req.headers.get("authorization")?.replace(/^Bearer\s+/i, "") ?? "";
+        if (!safeEqual(given, key)) {
+            return new Response("Unauthorized", { status: 401, headers: { "cache-control": "no-store", "www-authenticate": "Bearer" } });
+        }
+        const days = clampDays(url.searchParams.get("days"), opts.days ?? 30);
+        const now = (opts.now ?? (() => new Date()))();
+        const since = new Date(now.getTime() - days * 86400000).toISOString();
+        const summary = (0, stats_1.summarize)(await opts.store.list({ since }));
+        const headers = { "cache-control": "no-store", "x-robots-tag": "noindex, nofollow" };
+        if (url.searchParams.get("format") === "json") {
+            return new Response(JSON.stringify({ site: opts.site, days, ...summary }, null, 2), {
+                headers: { ...headers, "content-type": "application/json; charset=utf-8" },
+            });
+        }
+        return new Response((0, dashboard_1.renderDashboard)(summary, { site: opts.site, days }), {
+            headers: { ...headers, "content-type": "text/html; charset=utf-8" },
+        });
+    };
+    return { GET };
+}
+function clampDays(raw, fallback) {
+    const d = Number(raw);
+    return Number.isFinite(d) && d >= 1 ? Math.min(Math.floor(d), 365) : fallback;
+}
+/** Constant-time string compare, so the key can't be guessed by timing. */
+function safeEqual(a, b) {
+    let diff = a.length ^ b.length;
+    for (let i = 0; i < Math.max(a.length, b.length); i++)
+        diff |= (a.charCodeAt(i) || 0) ^ (b.charCodeAt(i) || 0);
+    return diff === 0;
+}