@adkinn/astro-ai-readiness 0.0.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adam Kinney, LLC (DBA Obaron)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,285 @@
+# @adkinn/astro-ai-readiness
+
+> AI Readiness toolkit for Astro — six JSON-LD helper components plus `dist/llms.txt`, `dist/llms-full.txt`, `dist/agents.md`, `dist/robots.txt`, and `dist/.well-known/mcp.json`.
+
+**Status:** v0.0.7 — seventh slice in prep. **Component sub-line complete (6 of 6); five of five v0.1 file outputs live.** Multi-output orchestration on the `astro:build:done` hook now covers the full v0.1 artifact set.
+
+## What ships in v0.0.7
+
+**Six JSON-LD components** (component sub-line complete):
+- `<OrganizationSchema />` — Organization block. Config-driven; place in your `BaseLayout` so it ships site-wide and the `#organization` `@id` reference resolves on every page.
+- `<WebSiteSchema />` — WebSite block. Config-driven; alongside `<OrganizationSchema />` in `BaseLayout`.
+- `<CollectionSchema name url description? />` — CollectionPage block. Props-driven; place on collection-index pages (`/articles/`, `/tags/[tag]/`, etc.).
+- `<BreadcrumbSchema items={[{ name, url }, ...]} />` — BreadcrumbList. Items-array prop; place on multi-level pages where the navigation hierarchy isn't already declared inline. Empty `items` skips emission.
+- `<FAQPageSchema items={[{ question, answer }, ...]} />` — FAQPage. Items-array prop; place on pages with FAQ data. Long-form answers escape `</script>` and U+2028 / U+2029 automatically. Empty `items` skips emission.
+- `<TechArticleSchema headline description datePublished {...optional} />` — TechArticle block. Heavy-props; place on article-detail pages. `author` defaults to a Person synthesized from `config.organization.founder`; pass an explicit `author` prop to override.
+
+**Five file outputs**:
+- `dist/llms.txt` — [llmstxt.org](https://llmstxt.org/) format from the `llmsTxt` config block. H1 / blockquote summary / optional body / H2 sections with bulleted links / optional canonical-reference footer. Opt-in.
+- `dist/llms-full.txt` — manual full-context markdown from the `llmsFull` config block. This is config-driven in v0.0.7; content-collection introspection is a later layer.
+- `dist/agents.md` — Markdown discovery file for AI-agent crawlers from the `agentsMd` config block. H1 / blockquote description / optional `## Audience`, `## Contact`, `## Links` sections. Opt-in.
+- `dist/.well-known/mcp.json` — [Model Context Protocol](https://modelcontextprotocol.io/) discovery file from the `mcp` config block. Pretty-printed JSON with `$schema` reference to the toolkit-published v1 shape (per D-22). Supports `status: 'active'` (requires `url` + `tools[]`) and `status: 'planned'` (requires `planned_tools[]`; `url` forbidden by schema). Opt-in.
+- `dist/robots.txt` — robots policy composition from the `robotsTxt` config block. Presets: `search-visible`, `training-opt-out` (default), and `private`; supports explicit bot rules, `Sitemap`, and optional `Content-Signal` directives.
+
+**`@astrojs/sitemap` detection per D-8.** When you call `aiReadiness({...})` and `@astrojs/sitemap` isn't in your integrations list, the toolkit logs a build-time warning. Sitemap is an AI-Readiness baseline; when `robotsTxt` is enabled, the generated `robots.txt` includes a `Sitemap` line by default.
+
+All six components emit canonical Schema.org JSON-LD with cross-component `@id` references (`#organization`, `#website`) so search and AI consumers can resolve the entity graph without redeclaring shared fields.
+
+URL config fields (`site`, `organization.url`, `organization.logo`, `founder.sameAs`, `llmsTxt.*.url`) require `https://` (or `http://localhost` for dev).
+
+Config validation errors are formatted with one issue per line — `path: message` per Zod issue — instead of the default `ZodError` JSON blob.
+
+## On the roadmap (toward v0.1.0)
+
+- v0.0.8 — fixture Astro app validation against AATT / adamkinney.com install paths; refine robots presets from real traffic policy.
+- v0.0.9 — content-collection assisted `llms-full.txt` generation.
+- v0.1.0 — polish, docs, release hardening; full install on adamkinney.com
+
+Track progress: <https://github.com/adkinn/astro-ai-readiness/milestones>
+
+## Install
+
+```bash
+npm install @adkinn/astro-ai-readiness
+```
+
+## Quick start
+
+Configure (v0.0.7 accepts `site`, `organization`, optional `webSite`, optional `llmsTxt`, optional `llmsFull`, optional `agentsMd`, optional `mcp`, and optional `robotsTxt` blocks — the Zod schema rejects unknown keys, and URL fields must use `https://` or `http://localhost`):
+
+```ts
+// astro.config.mjs
+import { defineConfig } from 'astro/config'
+import sitemap from '@astrojs/sitemap'
+import aiReadiness from '@adkinn/astro-ai-readiness'
+
+export default defineConfig({
+  site: 'https://your-site.com',
+  integrations: [
+    sitemap(),                              // recommended — AI Readiness baseline (D-8)
+    aiReadiness({
+      site: 'https://your-site.com',
+      organization: {
+        name: 'Your Brand',
+        url: 'https://your-site.com',
+        logo: 'https://your-site.com/logo.png',
+        founder: {
+          name: 'Your Name',
+          jobTitle: 'Founder',
+          sameAs: ['https://your-site.com', 'https://x.com/handle'],
+        },
+      },
+      webSite: {
+        // Optional. `name` defaults to organization.name when absent.
+        description: 'What your site does, in one sentence.',
+      },
+      llmsTxt: {
+        // Optional. When set, the toolkit ships dist/llms.txt at build time.
+        // Note: `summary` must be single-line — multi-paragraph summaries break
+        // the llms.txt blockquote shape. Use `body` (free-form markdown) for
+        // additional prose. Multi-line summary throws at config-validation time.
+        summary: 'What your site does, in one sentence — for AI agents discovering your content.',
+        body: 'A free-form markdown paragraph or two between summary and sections. Plain prose; no top-level H2 here (those are reserved for link sections below).',
+        sections: [
+          {
+            title: 'Articles',
+            links: [
+              { title: 'All Articles', url: 'https://your-site.com/articles/' },
+              { title: 'RSS Feed', url: 'https://your-site.com/rss.xml' },
+            ],
+          },
+        ],
+        deferTo: {
+          // Single canonical-reference link, rendered as a footer.
+          title: 'Articles Index',
+          url: 'https://your-site.com/articles/',
+        },
+      },
+      llmsFull: {
+        // Optional. When set, the toolkit ships dist/llms-full.txt at build time.
+        // v0.0.7 is manual/config-driven; later slices can derive sections from
+        // content collections.
+        sections: [
+          {
+            title: 'Site Context',
+            content: 'Long-form context agents should read before summarizing this site.',
+          },
+          {
+            title: 'Canonical Resources',
+            content: '- https://your-site.com/articles/\n- https://your-site.com/rss.xml',
+          },
+        ],
+      },
+      agentsMd: {
+        // Optional. When set, the toolkit ships dist/agents.md at build time.
+        description: 'What your site does and who it serves — for AI-agent crawlers.',
+        audience: 'Developers and AI agents acting on their behalf.',
+        contact: 'hello@your-site.com',
+        links: [
+          { title: 'Articles', url: 'https://your-site.com/articles/', description: 'All articles' },
+          { title: 'RSS Feed', url: 'https://your-site.com/rss.xml', description: 'Machine-readable article stream' },
+        ],
+      },
+      mcp: {
+        // Optional. When set, the toolkit ships dist/.well-known/mcp.json at build time.
+        // Each server must have status: 'active' or status: 'planned'.
+        // Active: requires url + tools[]. Planned: requires planned_tools[]; url is forbidden.
+        servers: [
+          {
+            // A live MCP server — must have url + tools.
+            status: 'active',
+            name: 'your-knowledge',
+            url: 'https://mcp.your-site.com',
+            description: 'MCP server exposing your site knowledge for AI agents.',
+            tools: [
+              { name: 'search_articles', description: 'Search articles by keyword or tag.' },
+              { name: 'fetch_article', description: 'Fetch a specific article by slug.' },
+            ],
+          },
+          {
+            // A planned server — declares intent without a live URL.
+            status: 'planned',
+            name: 'your-future-server',
+            description: 'Planned MCP server for future capability.',
+            planned_tools: [
+              { name: 'lookup', description: 'Lookup by ID once the server ships.' },
+            ],
+          },
+        ],
+      },
+      robotsTxt: {
+        // Optional. When set, the toolkit ships dist/robots.txt at build time.
+        // Default policy is "training-opt-out": ordinary search stays open while
+        // common model-training bot tokens are disallowed. Some vendors bundle
+        // training and grounding under one token, so override rules when needed.
+        policy: 'training-opt-out',
+        // Defaults to https://your-site.com/sitemap-index.xml. Set false to omit.
+        sitemap: 'https://your-site.com/sitemap-index.xml',
+        contentSignals: {
+          search: 'yes',
+          aiTrain: 'no',
+          aiInput: 'yes',
+        },
+        // Add or replace rules when your site has a specific bot policy.
+        additionalLines: [
+          '# Custom lines are appended before Sitemap.',
+        ],
+      },
+    }),
+  ],
+})
+```
+
+> **Note on raw markdown.** `llmsTxt.*`, `llmsFull.*`, and `agentsMd.*` string fields are emitted as raw markdown. If you're templating user-generated content into those fields, escape `]`, `)`, and leading `>` to avoid breaking the rendered Markdown shape. Author-controlled strings (typical case) need no escaping. `mcp.json` is JSON-serialized and has no markdown-injection surface.
+
+Use the components:
+
+```astro
+---
+// src/layouts/BaseLayout.astro — site-wide
+import { OrganizationSchema, WebSiteSchema } from '@adkinn/astro-ai-readiness/components'
+---
+<head>
+  <OrganizationSchema />
+  <WebSiteSchema />
+</head>
+```
+
+`<OrganizationSchema />` declares `@id: '<site>#organization'`; `<WebSiteSchema />` references it. Order matters in the head — Organization first.
+
+```astro
+---
+// src/pages/articles/index.astro — collection index pages
+import { CollectionSchema } from '@adkinn/astro-ai-readiness/components'
+---
+<CollectionSchema
+  name="All Articles"
+  url={new URL('articles/', Astro.site).toString()}
+  description="Production-tested articles, version-pinned environments."
+/>
+```
+
+```astro
+---
+// any multi-level page — site-context navigation
+import { BreadcrumbSchema } from '@adkinn/astro-ai-readiness/components'
+import type { BreadcrumbItem } from '@adkinn/astro-ai-readiness/components'
+
+const crumbs: BreadcrumbItem[] = [
+  { name: 'Home', url: new URL('/', Astro.site).toString() },
+  { name: 'Articles', url: new URL('/articles/', Astro.site).toString() },
+  { name: 'How agents handle errors', url: Astro.url.toString() },
+]
+---
+<BreadcrumbSchema items={crumbs} />
+```
+
+```astro
+---
+// pages with FAQ data — items-array of question/answer pairs
+import { FAQPageSchema } from '@adkinn/astro-ai-readiness/components'
+import type { FAQItem } from '@adkinn/astro-ai-readiness/components'
+
+const faqs: FAQItem[] = [
+  { question: 'What is X?', answer: 'X is...' },
+  { question: 'Why does Y matter?', answer: 'Because...' },
+]
+---
+<FAQPageSchema items={faqs} />
+```
+
+```astro
+---
+// article-detail pages — required props only
+import { TechArticleSchema } from '@adkinn/astro-ai-readiness/components'
+---
+<TechArticleSchema
+  headline="How agents handle errors"
+  description="A pattern for agent error handling that doesn't lose context."
+  datePublished="2026-04-01T12:00:00Z"
+/>
+```
+
+`<TechArticleSchema>` defaults `author` to a Person synthesized from `config.organization.founder` (name from `founder.name`, url from `founder.sameAs[0]`). Pass an explicit `author={{ name, url? }}` to override on multi-author sites. The component throws at build time if `author` is omitted and `founder` is unset — actionable error pointing at the `aiReadiness({...})` config.
+
+Advanced — full prop surface:
+
+```astro
+<TechArticleSchema
+  headline={article.title}
+  description={article.description}
+  datePublished={article.pubDate.toISOString()}
+  dateModified={(article.updatedDate ?? article.pubDate).toISOString()}
+  author={{ name: 'Guest Author', url: 'https://example.com' }}
+  image={{ url: 'https://your-site.com/og.png', width: 1200, height: 630 }}
+  articleSection="Tutorials"
+  keywords={['ai', 'agents', 'error-handling']}
+  proficiencyLevel="intermediate"
+  dependencies={['Node 22', 'Astro 5.5']}
+/>
+```
+
+Build your site (`npm run build`); inspect any `dist/*.html` — you'll see inline `<script type="application/ld+json">` blocks with cross-referenced `@id`s tying the entity graph together.
+
+## Design principles
+
+- **Zero client JS.** Every component emits inline `<script type="application/ld+json">` at build time. Hydrating JSON-LD would erode the very Schema.org category it's meant to lift.
+- **Compose, don't clobber.** `robotsTxt` exposes explicit rules and appended lines so user intent can override presets. If you already maintain a hand-written `public/robots.txt`, compare the generated file before adopting it.
+- **Composes with `@astrojs/sitemap`.** Doesn't replace it. The integration warns when sitemap is missing and `robotsTxt` defaults its `Sitemap` line to `/sitemap-index.xml`.
+
+## What's beyond v0.1
+
+The v0.1 line is content → artifacts: components and files. Build-time AI-readiness self-scoring, spec validation against [llmstxt.org](https://llmstxt.org), and content lints are on the v0.2 horizon — but not committed scope yet. v0.1 ships first.
+
+## Shipped on
+
+- [aiallthethings.com](https://aiallthethings.com) — AATT, the toolkit's first reference implementation. Runs all six components on production plus three toolkit-emitted files: `dist/llms.txt` at <https://aiallthethings.com/llms.txt>, `dist/agents.md` at <https://aiallthethings.com/agents.md>, and `dist/.well-known/mcp.json` at <https://aiallthethings.com/.well-known/mcp.json>. Components: Organization + WebSite (site-wide via BaseLayout), CollectionPage (articles + framework + tag indexes), BreadcrumbList (`/about`), FAQPage (articles with FAQ frontmatter), TechArticle (every article-detail page).
+- [adamkinney.com](https://adamkinney.com) — Adam Kinney's site. Next SSR reference-implementation target once v0.1.0 publishes.
+
+## Contributing
+
+PRs welcome. See [CONTRIBUTING.md](./.github/CONTRIBUTING.md) and our [Code of Conduct](./CODE_OF_CONDUCT.md).
+
+## License
+
+MIT — Copyright (c) 2026 Adam Kinney, LLC (DBA Obaron).

package/dist/chunk-36CGBNB5.js

@@ -0,0 +1,104 @@
+import {
+  writeOutput
+} from "./chunk-V22PCH7G.js";
+
+// src/outputs/robots-txt.ts
+var TRAINING_BOT_RULES = [
+  { userAgent: "GPTBot", disallow: ["/"], comment: "OpenAI training crawler" },
+  { userAgent: "Google-Extended", disallow: ["/"], comment: "Google Gemini training/grounding control token" },
+  { userAgent: "CCBot", disallow: ["/"], comment: "Common Crawl" },
+  { userAgent: "ClaudeBot", disallow: ["/"], comment: "Anthropic crawler" },
+  { userAgent: "anthropic-ai", disallow: ["/"], comment: "Anthropic crawler" },
+  { userAgent: "Applebot-Extended", disallow: ["/"], comment: "Apple AI training control token" }
+];
+var SEARCH_BOT_RULES = [
+  { userAgent: "*", allow: ["/"], comment: "Default web and search discovery" },
+  { userAgent: "OAI-SearchBot", allow: ["/"], comment: "OpenAI search crawler" }
+];
+function defaultSitemap(site) {
+  return new URL("sitemap-index.xml", site.endsWith("/") ? site : `${site}/`).toString();
+}
+function policyRules(policy) {
+  if (policy === "private") {
+    return [{ userAgent: "*", disallow: ["/"], comment: "Private site" }];
+  }
+  if (policy === "training-opt-out") {
+    return [...SEARCH_BOT_RULES, ...TRAINING_BOT_RULES];
+  }
+  return SEARCH_BOT_RULES;
+}
+function defaultContentSignals(policy) {
+  if (policy === "private") {
+    return { search: "no", aiTrain: "no", aiInput: "no" };
+  }
+  if (policy === "training-opt-out") {
+    return { search: "yes", aiTrain: "no", aiInput: "yes" };
+  }
+  return { search: "yes", aiTrain: "yes", aiInput: "yes" };
+}
+function composeRule(rule) {
+  const lines = [];
+  const userAgents = Array.isArray(rule.userAgent) ? rule.userAgent : [rule.userAgent];
+  if (rule.comment) lines.push(`# ${rule.comment}`);
+  for (const userAgent of userAgents) {
+    lines.push(`User-agent: ${userAgent}`);
+  }
+  for (const value of rule.allow ?? []) {
+    lines.push(`Allow: ${value}`);
+  }
+  for (const value of rule.disallow ?? []) {
+    lines.push(`Disallow: ${value}`);
+  }
+  if (rule.crawlDelay) {
+    lines.push(`Crawl-delay: ${rule.crawlDelay}`);
+  }
+  return lines;
+}
+function composeContentSignal(signals) {
+  const parts = [];
+  if (signals.search) parts.push(`search=${signals.search}`);
+  if (signals.aiTrain) parts.push(`ai-train=${signals.aiTrain}`);
+  if (signals.aiInput) parts.push(`ai-input=${signals.aiInput}`);
+  return `Content-Signal: ${parts.join(", ")}`;
+}
+function composeRobotsTxt(config) {
+  const robotsTxt = config.robotsTxt;
+  const policy = robotsTxt.policy ?? "training-opt-out";
+  const rules = robotsTxt.rules ?? policyRules(policy);
+  const signals = {
+    ...defaultContentSignals(policy),
+    ...robotsTxt.contentSignals
+  };
+  const sitemap = robotsTxt.sitemap === false ? void 0 : robotsTxt.sitemap ?? defaultSitemap(config.site);
+  const lines = [
+    "# Generated by @adkinn/astro-ai-readiness",
+    composeContentSignal(signals),
+    ""
+  ];
+  for (const rule of rules) {
+    lines.push(...composeRule(rule));
+    lines.push("");
+  }
+  if (robotsTxt.additionalLines && robotsTxt.additionalLines.length > 0) {
+    lines.push(...robotsTxt.additionalLines);
+    lines.push("");
+  }
+  if (sitemap) {
+    lines.push(`Sitemap: ${sitemap}`);
+    lines.push("");
+  }
+  return lines.join("\n").replace(/\n+$/, "\n");
+}
+async function writeRobotsTxt(config, dir, logger) {
+  if (!config.robotsTxt) return;
+  const content = composeRobotsTxt(
+    config
+  );
+  const target = new URL("robots.txt", dir);
+  await writeOutput(target, content, "robots.txt", logger);
+}
+
+export {
+  composeRobotsTxt,
+  writeRobotsTxt
+};

package/dist/chunk-BDGAXJOB.js

@@ -0,0 +1,42 @@
+import {
+  writeOutput
+} from "./chunk-V22PCH7G.js";
+
+// src/outputs/mcp-json.ts
+var MCP_SCHEMA_URL = "https://raw.githubusercontent.com/adkinn/astro-ai-readiness/v0.0.7/schemas/mcp/v1.json";
+function composeMcpJson(config) {
+  const { mcp } = config;
+  const obj = {
+    $schema: MCP_SCHEMA_URL,
+    version: mcp.version ?? "1.0",
+    servers: mcp.servers.map((s) => {
+      const server = {
+        name: s.name,
+        description: s.description,
+        status: s.status
+      };
+      if (s.status === "active") {
+        server.url = s.url;
+        server.tools = s.tools;
+      } else {
+        server.planned_tools = s.planned_tools;
+      }
+      return server;
+    })
+  };
+  return JSON.stringify(obj, null, 2) + "\n";
+}
+async function writeMcpJson(config, dir, logger) {
+  if (!config.mcp) return;
+  const content = composeMcpJson(
+    config
+  );
+  const subdir = new URL(".well-known/", dir);
+  const target = new URL(".well-known/mcp.json", dir);
+  await writeOutput(target, content, ".well-known/mcp.json", logger, subdir);
+}
+
+export {
+  composeMcpJson,
+  writeMcpJson
+};

package/dist/chunk-CADNETPK.js

@@ -0,0 +1,48 @@
+import {
+  writeOutput
+} from "./chunk-V22PCH7G.js";
+
+// src/outputs/agents-md.ts
+function composeAgentsMd(config) {
+  const { agentsMd, organization } = config;
+  const lines = [];
+  lines.push(`# ${organization.name}`);
+  lines.push("");
+  lines.push(`> ${agentsMd.description}`);
+  lines.push("");
+  if (agentsMd.audience) {
+    lines.push("## Audience");
+    lines.push("");
+    lines.push(agentsMd.audience.trimEnd());
+    lines.push("");
+  }
+  if (agentsMd.contact) {
+    lines.push("## Contact");
+    lines.push("");
+    lines.push(agentsMd.contact.trimEnd());
+    lines.push("");
+  }
+  if (agentsMd.links && agentsMd.links.length > 0) {
+    lines.push("## Links");
+    lines.push("");
+    for (const link of agentsMd.links) {
+      const desc = link.description ? `: ${link.description}` : "";
+      lines.push(`- [${link.title}](${link.url})${desc}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").replace(/\n+$/, "\n");
+}
+async function writeAgentsMd(config, dir, logger) {
+  if (!config.agentsMd) return;
+  const content = composeAgentsMd(
+    config
+  );
+  const target = new URL("agents.md", dir);
+  await writeOutput(target, content, "agents.md", logger);
+}
+
+export {
+  composeAgentsMd,
+  writeAgentsMd
+};

package/dist/chunk-CO2DB4IE.js

@@ -0,0 +1,141 @@
+// src/config.ts
+import { z } from "zod";
+var httpsUrl = z.string().url().refine(
+  (u) => u.startsWith("https://") || u.startsWith("http://localhost"),
+  { message: "URL must use https:// (or http://localhost for dev)" }
+);
+var founderSchema = z.object({
+  name: z.string().min(1),
+  jobTitle: z.string().optional(),
+  description: z.string().optional(),
+  sameAs: z.array(httpsUrl).optional()
+});
+var organizationSchema = z.object({
+  name: z.string().min(1),
+  url: httpsUrl.optional(),
+  logo: httpsUrl.optional(),
+  founder: founderSchema.optional(),
+  foundingDate: z.string().optional(),
+  knowsAbout: z.array(z.string()).optional(),
+  areaServed: z.string().optional()
+}).strict();
+var webSiteSchema = z.object({
+  name: z.string().optional(),
+  description: z.string().optional()
+}).strict();
+var llmsTxtLinkSchema = z.object({
+  title: z.string().min(1),
+  url: httpsUrl,
+  description: z.string().optional()
+}).strict();
+var llmsTxtSectionSchema = z.object({
+  title: z.string().min(1),
+  links: z.array(llmsTxtLinkSchema).min(1)
+}).strict();
+var llmsTxtSchema = z.object({
+  summary: z.string().min(1).refine(
+    (s) => !s.includes("\n"),
+    { message: "summary must be single-line \u2014 multi-paragraph summaries break llms.txt blockquote shape. Use the optional `body` field for additional prose." }
+  ),
+  body: z.string().optional(),
+  sections: z.array(llmsTxtSectionSchema).optional(),
+  deferTo: z.object({
+    title: z.string().min(1),
+    url: httpsUrl
+  }).strict().optional()
+}).strict();
+var llmsFullSectionSchema = z.object({
+  title: z.string().min(1),
+  content: z.string().min(1)
+}).strict();
+var llmsFullSchema = z.object({
+  title: z.string().min(1).optional(),
+  summary: z.string().min(1).optional(),
+  content: z.string().min(1).optional(),
+  sections: z.array(llmsFullSectionSchema).min(1).optional()
+}).strict().refine(
+  (value) => Boolean(value.content || value.sections),
+  { message: "llmsFull requires either `content` or `sections`" }
+);
+var agentsMdLinkSchema = z.object({
+  title: z.string().min(1),
+  url: httpsUrl,
+  description: z.string().optional()
+}).strict();
+var agentsMdSchema = z.object({
+  description: z.string().min(1).refine(
+    (s) => !s.includes("\n"),
+    { message: "description must be single-line \u2014 use audience/contact fields for additional prose" }
+  ),
+  audience: z.string().optional(),
+  contact: z.string().optional(),
+  links: z.array(agentsMdLinkSchema).min(1).optional()
+}).strict();
+var mcpToolSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1)
+}).strict();
+var mcpActiveServerSchema = z.object({
+  status: z.literal("active"),
+  name: z.string().min(1),
+  url: z.string().url(),
+  description: z.string().min(1),
+  tools: z.array(mcpToolSchema).min(1)
+}).strict();
+var mcpPlannedServerSchema = z.object({
+  status: z.literal("planned"),
+  name: z.string().min(1),
+  description: z.string().min(1),
+  planned_tools: z.array(mcpToolSchema).min(1)
+}).strict();
+var mcpServerSchema = z.discriminatedUnion("status", [
+  mcpActiveServerSchema,
+  mcpPlannedServerSchema
+]);
+var mcpSchema = z.object({
+  version: z.string().optional(),
+  servers: z.array(mcpServerSchema).min(1)
+}).strict();
+var robotsPath = z.string().min(1).refine(
+  (path) => path === "*" || path.startsWith("/"),
+  { message: "robots.txt paths must start with /, or be *" }
+);
+var robotsTxtRuleSchema = z.object({
+  userAgent: z.union([
+    z.string().min(1),
+    z.array(z.string().min(1)).min(1)
+  ]),
+  allow: z.array(robotsPath).min(1).optional(),
+  disallow: z.array(robotsPath).min(1).optional(),
+  crawlDelay: z.number().positive().optional(),
+  comment: z.string().min(1).optional()
+}).strict().refine(
+  (rule) => Boolean(rule.allow || rule.disallow),
+  { message: "robots.txt rules require `allow` or `disallow`" }
+);
+var contentSignalValueSchema = z.enum(["yes", "no"]);
+var robotsTxtSchema = z.object({
+  policy: z.enum(["search-visible", "training-opt-out", "private"]).optional(),
+  sitemap: z.union([httpsUrl, z.literal(false)]).optional(),
+  contentSignals: z.object({
+    search: contentSignalValueSchema.optional(),
+    aiTrain: contentSignalValueSchema.optional(),
+    aiInput: contentSignalValueSchema.optional()
+  }).strict().optional(),
+  rules: z.array(robotsTxtRuleSchema).min(1).optional(),
+  additionalLines: z.array(z.string()).optional()
+}).strict();
+var aiReadinessConfigSchema = z.object({
+  site: httpsUrl,
+  organization: organizationSchema,
+  webSite: webSiteSchema.optional(),
+  llmsTxt: llmsTxtSchema.optional(),
+  llmsFull: llmsFullSchema.optional(),
+  agentsMd: agentsMdSchema.optional(),
+  mcp: mcpSchema.optional(),
+  robotsTxt: robotsTxtSchema.optional()
+}).strict();
+
+export {
+  aiReadinessConfigSchema
+};