@relvehq/agent-ready 0.0.0-stage → 0.2.1

package/dist/core/config.js

@@ -0,0 +1,103 @@
+"use strict";
+// Configuration for @relvehq/agent-ready.
+//
+// `defineAgentReady()` fills in defaults once, so every other module can read
+// a fully resolved config. Only Web-standard types (Request, Response) appear
+// here: the core never depends on a framework.
+//
+// EDGE-SAFE. No Node APIs. Middleware bundles import this module.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VIA_HEADER = exports.DEFAULT_INTERNAL_HEADER = exports.DEFAULT_INTERNAL_PREFIX = exports.DEFAULT_NEGOTIATED_CACHE_CONTROL = exports.DEFAULT_CACHE_CONTROL = exports.ALWAYS_EXCLUDE = void 0;
+exports.defineAgentReady = defineAgentReady;
+exports.isEnabled = isEnabled;
+exports.isExcluded = isExcluded;
+exports.emitHit = emitHit;
+/** Never served as Markdown, whatever the venture's config says. */
+exports.ALWAYS_EXCLUDE = [
+    "/api",
+    "/_next",
+    "/admin",
+    "/super-admin",
+    "/auth",
+    "/login",
+    "/logout",
+    "/signup",
+    "/signin",
+    "/sign-in",
+    "/sign-up",
+];
+exports.DEFAULT_CACHE_CONTROL = "public, s-maxage=300, stale-while-revalidate=86400";
+exports.DEFAULT_NEGOTIATED_CACHE_CONTROL = "private, max-age=300";
+exports.DEFAULT_INTERNAL_PREFIX = "/__md";
+exports.DEFAULT_INTERNAL_HEADER = "x-agent-ready-internal";
+/** Request header the middleware adapter sets on its rewrite: how Markdown was asked for. */
+exports.VIA_HEADER = "x-agent-ready-via";
+function defineAgentReady(config) {
+    if (config.__resolved)
+        return config;
+    const c = config;
+    if (!c || typeof c.site !== "string" || !/^https?:\/\//.test(c.site)) {
+        throw new Error("agent-ready: config.site must be an absolute http(s) origin");
+    }
+    const internalPrefix = trimSlash(c.internalPrefix ?? exports.DEFAULT_INTERNAL_PREFIX);
+    return {
+        __resolved: true,
+        site: new URL(c.site).origin,
+        exclude: [...exports.ALWAYS_EXCLUDE, internalPrefix, ...(c.exclude ?? [])],
+        templates: c.templates ?? {},
+        store: c.store ?? null,
+        fallback: c.fallback ?? "convert",
+        cacheControl: c.cacheControl ?? exports.DEFAULT_CACHE_CONTROL,
+        negotiatedCacheControl: c.negotiatedCacheControl ?? exports.DEFAULT_NEGOTIATED_CACHE_CONTROL,
+        llms: c.llms ? { ...c.llms, path: c.llms.path ?? "/llms.txt" } : null,
+        onHit: c.onHit ?? null,
+        enabled: c.enabled ?? false,
+        internalPrefix,
+        internalHeader: (c.internalHeader ?? exports.DEFAULT_INTERNAL_HEADER).toLowerCase(),
+        fetchOrigin: c.fetchOrigin ?? null,
+        fetchTimeoutMs: c.fetchTimeoutMs ?? 8000,
+        minChars: c.minChars ?? 200,
+    };
+}
+/** The master switch. A throwing `enabled` function counts as off. */
+function isEnabled(cfg, request) {
+    if (typeof cfg.enabled === "boolean")
+        return cfg.enabled;
+    try {
+        return cfg.enabled(request) === true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Segment-aware prefix match: "/admin" excludes "/admin" and "/admin/x", not "/administrator". */
+function isExcluded(cfg, path) {
+    for (const rule of cfg.exclude) {
+        if (typeof rule === "string") {
+            const p = trimSlash(rule);
+            if (p === "" || p === "/")
+                continue;
+            if (path === p || path.startsWith(p + "/"))
+                return true;
+        }
+        else if (rule.test(path)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Fire-and-forget: never awaited by callers, never throws. */
+function emitHit(cfg, event) {
+    if (!cfg.onHit)
+        return;
+    try {
+        void Promise.resolve(cfg.onHit(event)).catch(() => { });
+    }
+    catch {
+        // A synchronous throw from the logger must not change the response.
+    }
+}
+function trimSlash(p) {
+    const t = p.replace(/\/+$/, "");
+    return t.startsWith("/") ? t : `/${t}`;
+}

package/dist/core/convert.d.ts

@@ -0,0 +1,22 @@
+import type { MarkdownDoc } from "./config";
+export interface ConvertOptions {
+    /** Absolute URL of the page: base for relative links and images. */
+    url: string;
+    /** Quality gate in characters of plain text. Default 200. */
+    minChars?: number;
+}
+export interface ConvertResult extends MarkdownDoc {
+    markdown: string;
+    textLength: number;
+    strategy: "readability" | "main" | "article" | "body";
+}
+type El = any;
+export declare function htmlToMarkdown(html: string, opts: ConvertOptions): ConvertResult | null;
+/**
+ * Next.js App Router streams Suspense content after the shell as
+ * `<div hidden id="S:n">…</div>` plus a script that swaps it in for the
+ * fallback that follows `<template id="B:n">` up to the `<!--/$-->` comment.
+ * Scripts never run here, so do the swap ourselves before [hidden] is stripped.
+ */
+export declare function unfoldNextStreaming(doc: El): void;
+export {};

package/dist/core/convert.js

@@ -0,0 +1,334 @@
+"use strict";
+// Convert: a page's HTML -> clean Markdown.
+//
+//   1. Read metadata (title, description, lang, canonical, JSON-LD) from <head>.
+//   2. Unfold Next.js streamed Suspense content (<div hidden id="S:n">) into
+//      its placeholder, so App Router pages convert with their real content.
+//   3. Strip chrome: script/style/nav/footer/forms/dialogs/cookie banners.
+//   4. Pick the main content: Mozilla Readability, unless it returns too little
+//      compared with <main>/<article>/<body>, which are used instead.
+//   5. Absolutize links and images, flatten block-level links, give header-less
+//      tables a header row so GFM can render them.
+//   6. Turndown + GFM (tables, strikethrough, task lists), then collapse whitespace.
+//   7. Quality gate: under `minChars` of plain text -> null (caller serves HTML).
+//
+// NODE ONLY (linkedom, turndown). Never import this from middleware.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.htmlToMarkdown = htmlToMarkdown;
+exports.unfoldNextStreaming = unfoldNextStreaming;
+const linkedom_1 = require("linkedom");
+const readability_1 = require("@mozilla/readability");
+const turndown_1 = __importDefault(require("turndown"));
+const turndown_plugin_gfm_1 = require("turndown-plugin-gfm");
+const JUNK = [
+    "script",
+    "style",
+    "noscript",
+    "template",
+    "iframe",
+    "object",
+    "embed",
+    "svg",
+    "canvas",
+    "video",
+    "audio",
+    "form",
+    "input",
+    "button",
+    "select",
+    "textarea",
+    "label",
+    "nav",
+    "footer",
+    "dialog",
+    "link",
+    "meta",
+    "[role=navigation]",
+    "[role=contentinfo]",
+    "[role=banner]",
+    "[role=dialog]",
+    "[role=alertdialog]",
+    "[role=search]",
+    "[aria-hidden=true]",
+    "[hidden]",
+].join(",");
+const COOKIE_RE = /(^|[\s_-])(cookie|cookies|consent|gdpr|onetrust|cookiebot|cc-window|cc-banner|cmp)([\s_-]|$)/i;
+const BLOCK = "div,p,section,article,header,ul,ol,li,table,h1,h2,h3,h4,h5,h6,blockquote,pre,figure";
+let turndown = null;
+function getTurndown() {
+    if (turndown)
+        return turndown;
+    const td = new turndown_1.default({
+        headingStyle: "atx",
+        codeBlockStyle: "fenced",
+        bulletListMarker: "-",
+        emDelimiter: "_",
+        strongDelimiter: "**",
+        linkStyle: "inlined",
+    });
+    td.use(turndown_plugin_gfm_1.gfm);
+    // Rules added later win (turndown unshifts them). Cells: one line each, pipes escaped,
+    // so a cell with paragraphs or <br> can't break the GFM table.
+    td.addRule("agentReadyCell", {
+        filter: ["th", "td"],
+        replacement(content, node) {
+            const parent = node.parentNode;
+            const index = parent ? Array.prototype.indexOf.call(parent.childNodes, node) : 0;
+            const firstCell = !parent || Array.prototype.slice.call(parent.childNodes, 0, index).every((n) => n.nodeName !== "TH" && n.nodeName !== "TD");
+            const text = content.replace(/\s*\n+\s*/g, " ").replace(/\|/g, "\\|").trim();
+            return (firstCell ? "| " : " ") + text + " |";
+        },
+    });
+    td.remove(["script", "style", "noscript", "iframe", "button", "form", "svg"]);
+    turndown = td;
+    return td;
+}
+function htmlToMarkdown(html, opts) {
+    if (typeof html !== "string" || !html.trim())
+        return null;
+    const minChars = opts.minChars ?? 200;
+    const pageUrl = opts.url;
+    const { document } = (0, linkedom_1.parseHTML)(html);
+    const meta = readMeta(document, pageUrl);
+    const firstH1 = textOf(document.querySelector("h1"));
+    unfoldNextStreaming(document);
+    stripChrome(document);
+    const root = document.querySelector("main") || document.querySelector("article") || document.body || document.documentElement;
+    const rootStrategy = document.querySelector("main")
+        ? "main"
+        : document.querySelector("article")
+            ? "article"
+            : "body";
+    const rootHtml = root ? root.innerHTML : "";
+    const rootText = textLength(root ? root.textContent : "");
+    let contentHtml = rootHtml;
+    let strategy = rootStrategy;
+    let readabilityTitle;
+    try {
+        const { document: rdoc } = (0, linkedom_1.parseHTML)(document.toString());
+        const article = new readability_1.Readability(rdoc, { charThreshold: minChars, keepClasses: false }).parse();
+        const articleText = textLength(article?.textContent ?? "");
+        // Readability is great on articles but can keep a fraction of a listing or
+        // profile page. Use it only when it kept most of what <main> holds.
+        if (article && article.content && articleText >= minChars && articleText >= rootText * 0.6) {
+            contentHtml = article.content;
+            strategy = "readability";
+            readabilityTitle = article.title || undefined;
+        }
+    }
+    catch {
+        // Readability failed on odd markup: the <main>/<body> fallback stands.
+    }
+    const { document: cdoc } = (0, linkedom_1.parseHTML)(`<!doctype html><html><head></head><body>${contentHtml}</body></html>`);
+    absolutize(cdoc, pageUrl);
+    flattenBlockLinks(cdoc);
+    headerRows(cdoc);
+    let markdown = getTurndown().turndown(cdoc.body.innerHTML);
+    markdown = tidy(markdown);
+    const heading = firstH1 || readabilityTitle || meta.title;
+    if (heading && !/^#\s/m.test(markdown))
+        markdown = `# ${oneLine(heading)}\n\n${markdown}`;
+    const textLen = plainTextLength(markdown);
+    if (!markdown || textLen < minChars)
+        return null;
+    return { markdown, textLength: textLen, strategy, ...meta };
+}
+// ── metadata ─────────────────────────────────────────────────────────────
+function readMeta(doc, pageUrl) {
+    const metaContent = (sel) => {
+        const v = doc.querySelector(sel)?.getAttribute("content");
+        return v ? oneLine(v) : undefined;
+    };
+    const title = metaContent('meta[property="og:title"]') || oneLine(textOf(doc.querySelector("title"))) || undefined;
+    const description = metaContent('meta[name="description"]') || metaContent('meta[property="og:description"]');
+    const lang = doc.documentElement?.getAttribute("lang") || undefined;
+    const canonicalHref = doc.querySelector('link[rel="canonical"]')?.getAttribute("href");
+    const canonical = canonicalHref ? absolute(canonicalHref, pageUrl) ?? undefined : undefined;
+    const jsonLd = [];
+    for (const s of Array.from(doc.querySelectorAll('script[type="application/ld+json"]'))) {
+        try {
+            jsonLd.push(JSON.parse(s.textContent || ""));
+        }
+        catch {
+            // Broken JSON-LD is skipped, not fatal.
+        }
+    }
+    return { title, description, lang, canonical, jsonLd };
+}
+// ── cleaning ─────────────────────────────────────────────────────────────
+/**
+ * Next.js App Router streams Suspense content after the shell as
+ * `<div hidden id="S:n">…</div>` plus a script that swaps it in for the
+ * fallback that follows `<template id="B:n">` up to the `<!--/$-->` comment.
+ * Scripts never run here, so do the swap ourselves before [hidden] is stripped.
+ */
+function unfoldNextStreaming(doc) {
+    for (const segment of Array.from(doc.querySelectorAll('div[hidden][id^="S:"]'))) {
+        const n = segment.getAttribute("id").slice(2);
+        const placeholder = doc.getElementById ? doc.getElementById(`B:${n}`) : doc.querySelector(`[id="B:${n}"]`);
+        if (!placeholder || !placeholder.parentNode) {
+            segment.removeAttribute("hidden");
+            continue;
+        }
+        // Drop the fallback between the placeholder and the closing <!--/$-->.
+        let next = placeholder.nextSibling;
+        while (next && !(next.nodeType === 8 && String(next.data).trim() === "/$")) {
+            const after = next.nextSibling;
+            next.parentNode.removeChild(next);
+            next = after;
+        }
+        while (segment.firstChild)
+            placeholder.parentNode.insertBefore(segment.firstChild, placeholder);
+        placeholder.parentNode.removeChild(placeholder);
+        segment.parentNode.removeChild(segment);
+    }
+}
+function stripChrome(doc) {
+    for (const el of Array.from(doc.querySelectorAll(JUNK)))
+        remove(el);
+    // Page-level <header> is site chrome; an <article>'s own <header> is content.
+    for (const el of Array.from(doc.querySelectorAll("header"))) {
+        if (!el.closest || !el.closest("main, article"))
+            remove(el);
+    }
+    for (const el of Array.from(doc.querySelectorAll('[style*="display:none"], [style*="display: none"]'))) {
+        remove(el);
+    }
+    // Cookie / consent banners, by id or class. Small elements only, so a
+    // `cookie-consent-open` class on a page wrapper can't wipe the page.
+    for (const el of Array.from(doc.querySelectorAll("[id], [class]"))) {
+        const tag = String(el.nodeName).toLowerCase();
+        if (tag === "html" || tag === "body" || tag === "main")
+            continue;
+        const hay = `${el.getAttribute("id") || ""} ${el.getAttribute("class") || ""}`;
+        if (COOKIE_RE.test(hay) && textLength(el.textContent || "") < 1500)
+            remove(el);
+    }
+}
+function remove(el) {
+    if (el && el.parentNode)
+        el.parentNode.removeChild(el);
+}
+// ── content fixes ────────────────────────────────────────────────────────
+function absolutize(doc, pageUrl) {
+    for (const a of Array.from(doc.querySelectorAll("a"))) {
+        const href = a.getAttribute("href");
+        const abs = href ? absolute(href, pageUrl) : null;
+        if (!abs || /^javascript:/i.test(abs)) {
+            unwrap(a);
+            continue;
+        }
+        a.setAttribute("href", abs);
+        a.removeAttribute("title");
+    }
+    for (const img of Array.from(doc.querySelectorAll("img"))) {
+        const raw = img.getAttribute("src") || img.getAttribute("data-src") || "";
+        let src = raw && !/^data:/i.test(raw) ? absolute(raw, pageUrl) : null;
+        // next/image: /_next/image?url=<original>&w=… -> the original asset.
+        if (src) {
+            try {
+                const u = new URL(src);
+                if (u.pathname === "/_next/image" && u.searchParams.get("url")) {
+                    src = absolute(u.searchParams.get("url"), pageUrl);
+                }
+            }
+            catch {
+                // keep src as is
+            }
+        }
+        if (!src) {
+            remove(img);
+            continue;
+        }
+        img.setAttribute("src", src);
+        img.removeAttribute("srcset");
+        if (!img.getAttribute("alt"))
+            img.setAttribute("alt", "");
+    }
+}
+/**
+ * A card-style link wrapping a heading and a paragraph would come out of
+ * turndown as a multi-line `[...](url)`, which is not valid Markdown. Link
+ * the heading instead, or collapse the link to one line of text.
+ */
+function flattenBlockLinks(doc) {
+    for (const a of Array.from(doc.querySelectorAll("a[href]"))) {
+        if (!a.querySelector(BLOCK))
+            continue;
+        const href = a.getAttribute("href");
+        const heading = a.querySelector("h1, h2, h3, h4, h5, h6");
+        if (heading) {
+            const link = doc.createElement("a");
+            link.setAttribute("href", href);
+            link.textContent = oneLine(heading.textContent || "");
+            heading.textContent = "";
+            heading.appendChild(link);
+            unwrap(a);
+        }
+        else {
+            a.textContent = oneLine(a.textContent || "").slice(0, 300);
+        }
+    }
+}
+/** GFM needs a header row; promote the first row of tables that have none. */
+function headerRows(doc) {
+    for (const table of Array.from(doc.querySelectorAll("table"))) {
+        if (table.querySelector("thead") || table.querySelector("th"))
+            continue;
+        const row = table.querySelector("tr");
+        if (!row)
+            continue;
+        for (const td of Array.from(row.querySelectorAll("td"))) {
+            const th = doc.createElement("th");
+            while (td.firstChild)
+                th.appendChild(td.firstChild);
+            td.parentNode.replaceChild(th, td);
+        }
+    }
+}
+function unwrap(el) {
+    const parent = el.parentNode;
+    if (!parent)
+        return;
+    while (el.firstChild)
+        parent.insertBefore(el.firstChild, el);
+    parent.removeChild(el);
+}
+// ── text helpers ─────────────────────────────────────────────────────────
+function tidy(md) {
+    return md
+        .replace(/\r\n?/g, "\n")
+        .replace(/ /g, " ")
+        .replace(/!?\[\s*\]\((?:[^()]|\([^)]*\))*\)/g, (m) => (m.startsWith("!") ? m : "")) // empty links
+        .replace(/[ \t]+$/gm, "")
+        .replace(/^[ \t]*[-*][ \t]*\n/gm, "") // empty bullets
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function plainTextLength(md) {
+    const text = md
+        .replace(/!\[[^\]]*\]\([^)]*\)/g, " ")
+        .replace(/\]\([^)]*\)/g, "]")
+        .replace(/[#*_>|`[\]-]/g, " ");
+    return textLength(text);
+}
+function textLength(s) {
+    return (s ?? "").replace(/\s+/g, " ").trim().length;
+}
+function textOf(el) {
+    return el ? oneLine(el.textContent || "") : "";
+}
+function oneLine(s) {
+    return s.replace(/\s+/g, " ").trim();
+}
+function absolute(href, base) {
+    try {
+        return new URL(href.trim(), base).href;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/core/detect.d.ts

@@ -0,0 +1,30 @@
+import type { Via } from "./config";
+export interface RequestLike {
+    url: string;
+    headers: {
+        get(name: string): string | null;
+    };
+}
+export interface Detection {
+    markdown: boolean;
+    /** Normalised page path without `.md`: leading slash, no trailing slash. */
+    path: string;
+    via: Exclude<Via, "direct"> | null;
+    llms: boolean;
+    /** The original query minus `format`, "" or "?a=b". */
+    search: string;
+}
+export interface DetectOptions {
+    /** Path llms.txt is served at, or null when the venture serves none. */
+    llmsPath?: string | null;
+}
+export declare function wantsMarkdown(request: RequestLike, opts?: DetectOptions): Detection;
+/**
+ * Leading slash, no trailing slash, no query or hash. Null for anything that
+ * isn't a plain path (traversal, backslashes, absurd length).
+ */
+export declare function normalizePath(raw: string | null | undefined): string | null;
+/** "/tool/x.md" -> "/tool/x", "/index.md" -> "/"; null when not a .md URL. */
+export declare function stripMdSuffix(pathname: string): string | null;
+/** "/tool/x" -> "/tool/x.md", "/" -> "/index.md". */
+export declare function mdUrlPath(path: string): string;

package/dist/core/detect.js

@@ -0,0 +1,82 @@
+"use strict";
+// Detect: does this request want Markdown, and for which page?
+//
+// Three ways to ask, in order of precedence:
+//   1. a `.md` suffix            /tool/notion.md, /index.md for "/"
+//   2. `?format=md`              /tool/notion?format=md (also format=markdown)
+//   3. the Accept header         text/markdown preferred over (or tied with)
+//                                text/html; a bare */* is NOT Markdown
+// plus the llms.txt path when one is configured.
+//
+// EDGE-SAFE. No Node APIs.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wantsMarkdown = wantsMarkdown;
+exports.normalizePath = normalizePath;
+exports.stripMdSuffix = stripMdSuffix;
+exports.mdUrlPath = mdUrlPath;
+const accept_1 = require("./accept");
+const MAX_PATH_LENGTH = 1024;
+function wantsMarkdown(request, opts = {}) {
+    let url;
+    try {
+        url = new URL(request.url);
+    }
+    catch {
+        return { markdown: false, path: "/", via: null, llms: false, search: "" };
+    }
+    const format = (url.searchParams.get("format") ?? "").toLowerCase();
+    const params = new URLSearchParams(url.searchParams);
+    params.delete("format");
+    const qs = params.toString();
+    const search = qs ? `?${qs}` : "";
+    if (opts.llmsPath && url.pathname === opts.llmsPath) {
+        return { markdown: true, path: opts.llmsPath, via: "llms", llms: true, search: "" };
+    }
+    const no = (path) => ({ markdown: false, path, via: null, llms: false, search: url.search });
+    const stripped = stripMdSuffix(url.pathname);
+    if (stripped !== null) {
+        const path = normalizePath(stripped);
+        return path ? { markdown: true, path, via: "suffix", llms: false, search } : no(url.pathname);
+    }
+    const path = normalizePath(url.pathname);
+    if (!path)
+        return no(url.pathname);
+    if (format === "md" || format === "markdown") {
+        return { markdown: true, path, via: "query", llms: false, search };
+    }
+    if ((0, accept_1.chooseFormat)(request.headers.get("accept")) === "markdown") {
+        // The query is kept whole: `format` was not used to ask.
+        return { markdown: true, path, via: "accept", llms: false, search: url.search };
+    }
+    return no(path);
+}
+/**
+ * Leading slash, no trailing slash, no query or hash. Null for anything that
+ * isn't a plain path (traversal, backslashes, absurd length).
+ */
+function normalizePath(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const path = raw.split("?")[0].split("#")[0];
+    if (!path.startsWith("/") || path.length > MAX_PATH_LENGTH)
+        return null;
+    // "//" is only allowed as a trailing run ("/a//" -> "/a"): "//host/x" would
+    // become a protocol-relative URL once joined to an origin.
+    if (path.includes("..") || path.includes("\\") || /\/\/./.test(path))
+        return null;
+    const trimmed = path.replace(/\/+$/, "");
+    return trimmed === "" ? "/" : trimmed;
+}
+/** "/tool/x.md" -> "/tool/x", "/index.md" -> "/"; null when not a .md URL. */
+function stripMdSuffix(pathname) {
+    if (!pathname.toLowerCase().endsWith(".md"))
+        return null;
+    if (pathname.toLowerCase() === "/index.md")
+        return "/";
+    const base = pathname.slice(0, -".md".length);
+    return base === "" || base.endsWith("/") ? null : base; // "/.md", "/docs/.md" are dotfiles
+}
+/** "/tool/x" -> "/tool/x.md", "/" -> "/index.md". */
+function mdUrlPath(path) {
+    return path === "/" ? "/index.md" : `${path}.md`;
+}

package/dist/core/easy.d.ts

@@ -0,0 +1,19 @@
+import { type AgentReadyConfig, type LlmsConfig, type ResolvedAgentReadyConfig } from "./config";
+import { type HitStore } from "../proof/hits";
+/** Private pages most sites have, never served as Markdown by the easy config. */
+export declare const COMMON_PRIVATE_PATHS: readonly string[];
+export type Env = Record<string, string | undefined>;
+export interface EasyOptions extends Omit<Partial<AgentReadyConfig>, "llms"> {
+    /** false: serve no llms.txt. An object: your own (as in `defineAgentReady`). Default: from the sitemap. */
+    llms?: LlmsConfig | false | null;
+    /** Add COMMON_PRIVATE_PATHS to the exclude list. Default true. */
+    excludeCommon?: boolean;
+    /** Record every visit here too (for the dashboard), alongside any reporter. */
+    hits?: HitStore | null;
+}
+/** The site's public origin from the usual env vars, or null. */
+export declare function siteFromEnv(env: Env): string | null;
+/** AGENT_READY_ENABLED is "1" or "true". */
+export declare function enabledFromEnv(env: Env): boolean;
+export declare function createAgentReady(options?: EasyOptions, env?: Env): ResolvedAgentReadyConfig;
+export declare const NO_SITE_WARNING = "agent-ready: no site URL, so it stays off. Set NEXT_PUBLIC_SITE_URL (e.g. https://example.com) or pass createAgentReady({ site }).";