livemark 0.26.0 → 0.27.1

package/source/helpers/llms.ts

@@ -0,0 +1,109 @@
+import type { Config } from "../models/config.ts"
+import type { RoutedSection } from "../models/section.ts"
+import {
+  buildArticleTree,
+  compareArticleDate,
+  compareArticleOrder,
+  flattenArticleTree,
+} from "./article.ts"
+import { partitionBySection } from "./section.ts"
+
+/** The slice of a built article that agent-facing files are rendered from. */
+export interface LlmsArticle {
+  path: string
+  title: string
+  description?: string
+  order?: number
+  date?: string
+}
+
+/** Render `llms.txt`: the site title and description, then one Markdown link
+ *  per article twin, grouped under each routed section in sidebar order. */
+export function renderLlmsText(props: {
+  config: Pick<Config, "title" | "description" | "site" | "base" | "sections">
+  articles: LlmsArticle[]
+}) {
+  const lines = [`# ${props.config.title}`, "", `> ${props.config.description}`]
+  for (const group of groupArticles(props)) {
+    lines.push("", `## ${group.title}`, "", ...renderLinks(props.config, group.articles))
+  }
+  return `${lines.join("\n")}\n`
+}
+
+/** Render the Markdown twin of a section's index page (a blog or changelog
+ *  listing), which has no article of its own: links to the section's articles. */
+export function renderSectionIndex(props: {
+  config: Pick<Config, "site" | "base" | "sections">
+  section: RoutedSection
+  articles: LlmsArticle[]
+}) {
+  const group = groupArticles(props).find(g => g.prefix === props.section.prefix)
+  const lines = [
+    `# ${props.section.title}`,
+    "",
+    ...renderLinks(props.config, group?.articles ?? []),
+  ]
+  return `${lines.join("\n")}\n`
+}
+
+/** Render the Markdown twin of an article: its title and description as the
+ *  rendered page shows them, then the body without its own leading h1. */
+export function renderMarkdownTwin(props: { article: LlmsArticle; content: string }) {
+  const article = props.article
+  const parts = [`# ${article.title}`]
+  if (article.description) parts.push(`> ${article.description}`)
+  parts.push(stripLeadingH1(props.content).trim())
+  return `${parts.join("\n\n")}\n`
+}
+
+/** Path of an article's Markdown twin inside the build output (no base). */
+export function buildTwinFileName(path: string) {
+  return `${path.replace(/^\//, "")}index.md`
+}
+
+/** Drop a leading h1 so a title set by frontmatter or a patch is not shown twice */
+export function stripLeadingH1(content: string) {
+  return content.replace(/^[ \t]*#\s+[^\n]*\n+/, "")
+}
+
+function buildTwinUrl(config: Pick<Config, "site" | "base">, path: string) {
+  const host = config.site?.replace(/\/+$/, "") ?? ""
+  return `${host}${config.base ?? ""}${path}index.md`
+}
+
+function groupArticles(props: {
+  config: Pick<Config, "sections">
+  articles: LlmsArticle[]
+}) {
+  const sections =
+    props.config.sections?.filter((s): s is RoutedSection => s.type !== "custom") ?? []
+  const buckets = partitionBySection(
+    [...props.articles].sort(compareArticleOrder),
+    sections,
+  )
+  const groups = [
+    ...sections.map(s => ({
+      prefix: s.prefix,
+      title: s.title,
+      dated: s.type !== "article",
+    })),
+    { prefix: "__default__", title: sections.length ? "Other" : "Pages", dated: false },
+  ]
+  return groups.flatMap(group => {
+    const bucket = buckets.get(group.prefix)
+    if (!bucket?.length) return []
+    const articles = group.dated
+      ? [...bucket].sort(compareArticleDate)
+      : flattenArticleTree(buildArticleTree(bucket)).flatMap(
+          path => bucket.find(a => a.path === path) ?? [],
+        )
+    return [{ prefix: group.prefix, title: group.title, articles }]
+  })
+}
+
+function renderLinks(config: Pick<Config, "site" | "base">, articles: LlmsArticle[]) {
+  return articles.map(article => {
+    const link = `[${article.title}](${buildTwinUrl(config, article.path)})`
+    return article.description ? `- ${link}: ${article.description}` : `- ${link}`
+  })
+}

package/source/helpers/llms.unit.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vite-plus/test"
+import type { RoutedSection } from "../models/section.ts"
+import {
+  buildTwinFileName,
+  renderLlmsText,
+  renderMarkdownTwin,
+  renderSectionIndex,
+} from "./llms.ts"
+
+const config = { title: "Docs", description: "Blurb" }
+
+describe("renderLlmsText", () => {
+  it("lists articles in sidebar order under a single heading without sections", () => {
+    const text = renderLlmsText({
+      config,
+      articles: [
+        { path: "/guide/", title: "Guide", order: 2 },
+        { path: "/intro/", title: "Intro", description: "Start here", order: 1 },
+        { path: "/guide/deep/", title: "Deep" },
+      ],
+    })
+    expect(text).toBe(
+      [
+        "# Docs",
+        "",
+        "> Blurb",
+        "",
+        "## Pages",
+        "",
+        "- [Intro](/intro/index.md): Start here",
+        "- [Guide](/guide/index.md)",
+        "- [Deep](/guide/deep/index.md)",
+        "",
+      ].join("\n"),
+    )
+  })
+
+  it("groups by routed section, newest first in a blog, with absolute urls", () => {
+    const text = renderLlmsText({
+      config: {
+        ...config,
+        site: "https://example.com/",
+        base: "/repo",
+        sections: [
+          { title: "Docs", prefix: "/", type: "article", position: "header" },
+          { title: "Blog", prefix: "/blog/", type: "blog", position: "header" },
+          {
+            title: "GitHub",
+            url: "https://github.com",
+            type: "custom",
+            position: "header",
+          },
+        ],
+      },
+      articles: [
+        { path: "/blog/old/", title: "Old", date: "2026-01-01" },
+        { path: "/intro/", title: "Intro" },
+        { path: "/blog/new/", title: "New", date: "2026-02-01" },
+      ],
+    })
+    expect(text).toContain(
+      [
+        "## Docs",
+        "",
+        "- [Intro](https://example.com/repo/intro/index.md)",
+        "",
+        "## Blog",
+        "",
+        "- [New](https://example.com/repo/blog/new/index.md)",
+        "- [Old](https://example.com/repo/blog/old/index.md)",
+      ].join("\n"),
+    )
+    expect(text).not.toContain("GitHub")
+  })
+})
+
+describe("renderSectionIndex", () => {
+  it("lists only the section's articles, newest first", () => {
+    const blog: RoutedSection = {
+      title: "Blog",
+      prefix: "/blog/",
+      type: "blog",
+      position: "header",
+    }
+    const text = renderSectionIndex({
+      config: { sections: [blog] },
+      section: blog,
+      articles: [
+        { path: "/intro/", title: "Intro" },
+        { path: "/blog/old/", title: "Old", date: "2026-01-01" },
+        { path: "/blog/new/", title: "New", date: "2026-02-01", description: "Fresh" },
+      ],
+    })
+    expect(text).toBe(
+      "# Blog\n\n- [New](/blog/new/index.md): Fresh\n- [Old](/blog/old/index.md)\n",
+    )
+  })
+})
+
+describe("renderMarkdownTwin", () => {
+  it("leads with the title and description instead of the body's own h1", () => {
+    const twin = renderMarkdownTwin({
+      article: { path: "/intro/", title: "Introduction", description: "Start here" },
+      content: "# Livemark\n\nBody text\n",
+    })
+    expect(twin).toBe("# Introduction\n\n> Start here\n\nBody text\n")
+  })
+})
+
+describe("buildTwinFileName", () => {
+  it("places the twin beside the page's index.html", () => {
+    expect(buildTwinFileName("/")).toBe("index.md")
+    expect(buildTwinFileName("/guide/deep/")).toBe("guide/deep/index.md")
+  })
+})

package/source/helpers/resolve-includes.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs"
+import { readFile } from "node:fs/promises"
 import { dirname, extname, resolve } from "node:path"
 
 const INCLUDE_RE = /^::include\{(.+)\}$/
@@ -56,18 +56,14 @@ function parseAttributes(raw: string): Record<string, string> {
   return attrs
 }
 
-function resolveDirective(
-  rawAttrs: string,
-  fileDir: string,
-  depth: number,
-): string | undefined {
+async function resolveDirective(rawAttrs: string, fileDir: string, depth: number) {
   const attrs = parseAttributes(rawAttrs)
   const file = attrs.file
   if (!file) return undefined
 
   const absolutePath = resolve(fileDir, file)
   try {
-    let included = readFileSync(absolutePath, "utf-8")
+    let included = await readFile(absolutePath, "utf-8")
 
     const ext = extname(file).toLowerCase()
     const lang = extToLang[ext]
@@ -87,12 +83,16 @@ function resolveDirective(
 }
 
 /** Resolves ::include{file="..."} directives by replacing them with referenced file contents */
-export function resolveIncludes(content: string, filePath: string, depth = 0): string {
+export async function resolveIncludes(
+  content: string,
+  filePath: string,
+  depth = 0,
+): Promise<string> {
   if (depth > 5) return content
 
   const fileDir = dirname(filePath)
   const lines = content.split("\n")
-  const result: string[] = []
+  const result: Array<string | Promise<string>> = []
   let fenceMarker: string | undefined
 
   for (const line of lines) {
@@ -114,12 +114,12 @@ export function resolveIncludes(content: string, filePath: string, depth = 0): s
 
     const includeMatch = INCLUDE_RE.exec(line)
     if (includeMatch) {
-      const resolved = resolveDirective(includeMatch[1]!, fileDir, depth)
-      result.push(resolved ?? line)
+      const directive = resolveDirective(includeMatch[1]!, fileDir, depth)
+      result.push(directive.then(resolved => resolved ?? line))
     } else {
       result.push(line)
     }
   }
 
-  return result.join("\n")
+  return (await Promise.all(result)).join("\n")
 }

package/source/helpers/resolve-includes.unit.ts

@@ -5,83 +5,104 @@ import { temporaryDirectory } from "tempy"
 import { resolveIncludes } from "./resolve-includes.ts"
 
 describe("resolveIncludes", () => {
-  it("should replace include directive with file content", () => {
+  it("should replace include directive with file content", async () => {
     const dir = temporaryDirectory()
     writeFileSync(join(dir, "snippet.md"), "Hello from snippet")
-    const result = resolveIncludes('::include{file="snippet.md"}', join(dir, "main.md"))
+    const result = await resolveIncludes(
+      '::include{file="snippet.md"}',
+      join(dir, "main.md"),
+    )
     expect(result).toBe("Hello from snippet")
   })
 
-  it("should strip frontmatter from included files", () => {
+  it("should strip frontmatter from included files", async () => {
     const dir = temporaryDirectory()
     writeFileSync(join(dir, "snippet.md"), "---\ntitle: Test\n---\nContent here")
-    const result = resolveIncludes('::include{file="snippet.md"}', join(dir, "main.md"))
+    const result = await resolveIncludes(
+      '::include{file="snippet.md"}',
+      join(dir, "main.md"),
+    )
     expect(result).toBe("Content here")
   })
 
-  it("should preserve surrounding content", () => {
+  it("should preserve surrounding content", async () => {
     const dir = temporaryDirectory()
     writeFileSync(join(dir, "snippet.md"), "Included text")
-    const result = resolveIncludes(
+    const result = await resolveIncludes(
       'Before\n\n::include{file="snippet.md"}\n\nAfter',
       join(dir, "main.md"),
     )
     expect(result).toBe("Before\n\nIncluded text\n\nAfter")
   })
 
-  it("should keep directive when file is missing", () => {
-    const result = resolveIncludes('::include{file="nonexistent.md"}', "/tmp/main.md")
+  it("should keep directive when file is missing", async () => {
+    const result = await resolveIncludes(
+      '::include{file="nonexistent.md"}',
+      "/tmp/main.md",
+    )
     expect(result).toBe('::include{file="nonexistent.md"}')
   })
 
-  it("should resolve nested includes", () => {
+  it("should resolve nested includes", async () => {
     const dir = temporaryDirectory()
     writeFileSync(join(dir, "inner.md"), "Inner content")
     writeFileSync(join(dir, "outer.md"), '::include{file="inner.md"}')
-    const result = resolveIncludes('::include{file="outer.md"}', join(dir, "main.md"))
+    const result = await resolveIncludes(
+      '::include{file="outer.md"}',
+      join(dir, "main.md"),
+    )
     expect(result).toBe("Inner content")
   })
 
-  it("should limit recursion depth", () => {
+  it("should limit recursion depth", async () => {
     const dir = temporaryDirectory()
     writeFileSync(join(dir, "recursive.md"), '::include{file="recursive.md"}')
-    const result = resolveIncludes('::include{file="recursive.md"}', join(dir, "main.md"))
+    const result = await resolveIncludes(
+      '::include{file="recursive.md"}',
+      join(dir, "main.md"),
+    )
     expect(result).toBe('::include{file="recursive.md"}')
   })
 
-  it("should resolve relative paths from included file location", () => {
+  it("should resolve relative paths from included file location", async () => {
     const dir = temporaryDirectory()
     mkdirSync(join(dir, "sub"))
     writeFileSync(join(dir, "sub", "child.md"), "Child content")
     writeFileSync(join(dir, "parent.md"), '::include{file="sub/child.md"}')
-    const result = resolveIncludes('::include{file="parent.md"}', join(dir, "main.md"))
+    const result = await resolveIncludes(
+      '::include{file="parent.md"}',
+      join(dir, "main.md"),
+    )
     expect(result).toBe("Child content")
   })
 
-  it("should handle multiple includes in one file", () => {
+  it("should handle multiple includes in one file", async () => {
     const dir = temporaryDirectory()
     writeFileSync(join(dir, "a.md"), "Alpha")
     writeFileSync(join(dir, "b.md"), "Beta")
-    const result = resolveIncludes(
+    const result = await resolveIncludes(
       '::include{file="a.md"}\n\n::include{file="b.md"}',
       join(dir, "main.md"),
     )
     expect(result).toBe("Alpha\n\nBeta")
   })
 
-  it("should wrap code files in fenced blocks", () => {
+  it("should wrap code files in fenced blocks", async () => {
     const dir = temporaryDirectory()
     writeFileSync(join(dir, "example.ts"), 'const x = 1\nconst y = "hello"')
-    const result = resolveIncludes('::include{file="example.ts"}', join(dir, "main.md"))
+    const result = await resolveIncludes(
+      '::include{file="example.ts"}',
+      join(dir, "main.md"),
+    )
     expect(result).toBe(
       '```typescript title="example.ts"\nconst x = 1\nconst y = "hello"\n```',
     )
   })
 
-  it("should pass meta to code fence", () => {
+  it("should pass meta to code fence", async () => {
     const dir = temporaryDirectory()
     writeFileSync(join(dir, "app.tsx"), "export default function App() {}")
-    const result = resolveIncludes(
+    const result = await resolveIncludes(
       '::include{file="app.tsx" meta="{1} lineNumbers"}',
       join(dir, "main.md"),
     )
@@ -90,10 +111,13 @@ describe("resolveIncludes", () => {
     )
   })
 
-  it("should treat unknown extensions as markdown", () => {
+  it("should treat unknown extensions as markdown", async () => {
     const dir = temporaryDirectory()
     writeFileSync(join(dir, "notes.txt"), "Plain text")
-    const result = resolveIncludes('::include{file="notes.txt"}', join(dir, "main.md"))
+    const result = await resolveIncludes(
+      '::include{file="notes.txt"}',
+      join(dir, "main.md"),
+    )
     expect(result).toBe("Plain text")
   })
 })

package/source/models/config.ts

@@ -31,6 +31,15 @@ export const Head = z.object({
   scripts: z.array(z.record(z.string(), z.string())).optional(),
 })
 
+/** How automated systems may use the site's content, published as a
+ *  `Content-Signal` line in the generated `robots.txt`. */
+export type ContentSignals = z.infer<typeof ContentSignals>
+export const ContentSignals = z.object({
+  search: z.boolean().default(true),
+  aiInput: z.boolean().default(true),
+  aiTrain: z.boolean().default(true),
+})
+
 /**
  * User-provided configuration for Livemark.
  *
@@ -64,6 +73,8 @@ export const UserConfig = z.object({
   sections: z.array(Section).optional(),
   patches: z.array(Patch).optional(),
   head: Head.optional(),
+  contentSignals: ContentSignals.prefault({}),
+  skills: z.union([z.string(), z.array(z.string())]).optional(),
   // Stored as `unknown` in the schema (zod can't type a Vite UserConfig
   // or a function returning one meaningfully); the public TypeScript
   // surface above lifts it back to ViteOverride for editor support.

package/source/plugins/vite-agents.ts

@@ -0,0 +1,137 @@
+import { existsSync, readFileSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { pathToFileURL } from "node:url"
+import type { Plugin } from "vite"
+import { z } from "zod"
+import {
+  buildSkillFileName,
+  loadAgentSkills,
+  renderSkillsIndex,
+} from "../helpers/agent-skills.ts"
+import {
+  buildTwinFileName,
+  renderLlmsText,
+  renderMarkdownTwin,
+  renderSectionIndex,
+} from "../helpers/llms.ts"
+import { resolveIncludes } from "../helpers/resolve-includes.ts"
+import type { Config } from "../models/config.ts"
+
+export interface AgentsOptions {
+  config: Config
+}
+
+const GeneratedArticles = z.array(
+  z.object({
+    path: z.string(),
+    title: z.string(),
+    description: z.string().optional(),
+    order: z.number().optional(),
+    date: z.string().optional(),
+    file: z.string(),
+    content: z.string(),
+  }),
+)
+
+/** Emit what AI agents look for into the client build: a Markdown twin of
+ *  every article and section listing at `<path>index.md`, `llms.txt`, the Agent Skills index for
+ *  `config.skills`, and a `_headers` file whose `Link` points agents at them. */
+export function agents(opts: AgentsOptions): Plugin {
+  const publicDir = join(opts.config.root, ".livemark", "public")
+  let root = ""
+  return {
+    name: "livemark:agents",
+    applyToEnvironment(env) {
+      return env.name === "client"
+    },
+    configResolved(resolved) {
+      root = resolved.root
+    },
+    async generateBundle() {
+      // Vite copies the publicDir before writeBundle, so emitting a file the
+      // project ships under `.livemark/public/` would silently replace it.
+      const emit = (fileName: string, source: string | Buffer) => {
+        if (existsSync(join(publicDir, fileName))) return
+        this.emitFile({ type: "asset", fileName, source })
+      }
+
+      const articles = await loadGeneratedArticles(root)
+      const contents = await Promise.all(
+        articles.map(article =>
+          resolveIncludes(article.content, resolve(opts.config.root, article.file)),
+        ),
+      )
+      articles.forEach((article, index) => {
+        const content = contents[index] ?? article.content
+        emit(buildTwinFileName(article.path), renderMarkdownTwin({ article, content }))
+      })
+
+      const llms = renderLlmsText({ config: opts.config, articles })
+      emit("llms.txt", llms)
+      const hasTwin = (path: string) => articles.some(a => a.path === path)
+      if (!hasTwin("/")) emit("index.md", llms)
+      // A rewrite to a missing twin is a 404, so every listing page needs one too.
+      for (const section of opts.config.sections ?? []) {
+        if (section.type === "custom" || section.prefix === "/") continue
+        if (hasTwin(section.prefix)) continue
+        emit(
+          buildTwinFileName(section.prefix),
+          renderSectionIndex({ config: opts.config, section, articles }),
+        )
+      }
+
+      const patterns = opts.config.skills ?? []
+      const skills = loadAgentSkills({
+        root: opts.config.root,
+        patterns: Array.isArray(patterns) ? patterns : [patterns],
+      })
+      for (const skill of skills) emit(buildSkillFileName(skill.name), skill.source)
+      if (skills.length) {
+        emit(
+          ".well-known/agent-skills/index.json",
+          renderSkillsIndex({ skills, base: opts.config.base }),
+        )
+      }
+
+      const headersFile = join(publicDir, "_headers")
+      this.emitFile({
+        type: "asset",
+        fileName: "_headers",
+        source: renderHeaders({
+          base: opts.config.base,
+          hasSkills: skills.length > 0,
+          existing: existsSync(headersFile) ? readFileSync(headersFile, "utf-8") : "",
+        }),
+      })
+    },
+  }
+}
+
+/** Render `_headers` (Cloudflare, Netlify): a `Link` on the home page naming
+ *  `llms.txt`, its Markdown twin and the skills index, after any rules the
+ *  project ships itself. */
+export function renderHeaders(props: {
+  base?: string
+  hasSkills: boolean
+  existing?: string
+}) {
+  const base = props.base ?? ""
+  const links = [
+    `<${base}/llms.txt>; rel="describedby"; type="text/plain"`,
+    `<${base}/index.md>; rel="alternate"; type="text/markdown"`,
+  ]
+  if (props.hasSkills) {
+    links.push(
+      `<${base}/.well-known/agent-skills/index.json>; rel="describedby"; type="application/json"`,
+    )
+  }
+  const rule = `${base}/\n  Link: ${links.join(", ")}\n`
+  const existing = props.existing?.trimEnd()
+  return existing ? `${existing}\n\n${rule}` : rule
+}
+
+async function loadGeneratedArticles(root: string) {
+  const file = join(root, ".content-collections", "generated", "allArticles.js")
+  const module: { default: unknown } = await import(pathToFileURL(file).href)
+  return GeneratedArticles.parse(module.default)
+}

package/source/plugins/vite-agents.unit.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vite-plus/test"
+import { renderHeaders } from "./vite-agents.ts"
+
+describe("renderHeaders", () => {
+  it("links the home page to llms.txt and its markdown twin", () => {
+    expect(renderHeaders({ hasSkills: false })).toBe(
+      '/\n  Link: </llms.txt>; rel="describedby"; type="text/plain", </index.md>; rel="alternate"; type="text/markdown"\n',
+    )
+  })
+
+  it("adds the skills index and mounts everything under base", () => {
+    const headers = renderHeaders({ base: "/repo", hasSkills: true })
+    expect(headers.startsWith("/repo/\n  Link: </repo/llms.txt>")).toBe(true)
+    expect(headers).toContain(
+      '</repo/.well-known/agent-skills/index.json>; rel="describedby"; type="application/json"',
+    )
+  })
+
+  it("keeps the project's own rules ahead of the generated one", () => {
+    const headers = renderHeaders({
+      hasSkills: false,
+      existing: "/*\n  X-Frame-Options: DENY\n\n",
+    })
+    expect(headers.startsWith("/*\n  X-Frame-Options: DENY\n\n/\n  Link: ")).toBe(true)
+  })
+})

package/source/plugins/vite-robots.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs"
 import { join } from "node:path"
 import type { Plugin } from "vite"
-import type { Config } from "../models/config.ts"
+import type { Config, ContentSignals } from "../models/config.ts"
 
 export interface RobotsOptions {
   config: Config
@@ -35,8 +35,13 @@ export function robots(opts: RobotsOptions): Plugin {
  *  line is appended only when `site` is set, because the directive
  *  requires a fully-qualified URL; `base` is included so the URL matches
  *  where the build (and the `sitemap.xml` inside it) is actually mounted. */
-export function renderRobots(config: Pick<Config, "site" | "base">) {
-  const lines = ["User-agent: *", "Allow: /"]
+export function renderRobots(
+  config: Pick<Config, "site" | "base"> & { contentSignals?: ContentSignals },
+) {
+  const lines = ["User-agent: *"]
+  // Agents read the signal as part of a user-agent group, so it must sit inside one.
+  if (config.contentSignals) lines.push(renderContentSignal(config.contentSignals))
+  lines.push("Allow: /")
   if (config.site) {
     const host = config.site.replace(/\/+$/, "")
     const base = config.base ?? ""
@@ -44,3 +49,13 @@ export function renderRobots(config: Pick<Config, "site" | "base">) {
   }
   return `${lines.join("\n")}\n`
 }
+
+function renderContentSignal(signals: ContentSignals) {
+  const flag = (value: boolean) => (value ? "yes" : "no")
+  const pairs = [
+    `search=${flag(signals.search)}`,
+    `ai-input=${flag(signals.aiInput)}`,
+    `ai-train=${flag(signals.aiTrain)}`,
+  ]
+  return `Content-Signal: ${pairs.join(", ")}`
+}

package/source/plugins/vite-robots.unit.ts

@@ -27,4 +27,11 @@ describe("renderRobots", () => {
   it("ignores base when site is not set", () => {
     expect(renderRobots({ base: "/repo" })).toBe("User-agent: *\nAllow: /\n")
   })
+
+  it("puts the content signals inside the wildcard group", () => {
+    const contentSignals = { search: true, aiInput: true, aiTrain: false }
+    expect(renderRobots({ contentSignals })).toBe(
+      "User-agent: *\nContent-Signal: search=yes, ai-input=yes, ai-train=no\nAllow: /\n",
+    )
+  })
 })