toiljs 0.0.11 → 0.0.12

package/test/pages.test.ts

@@ -0,0 +1,105 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { buildPageIndex, pagesModuleSource } from '../src/compiler/pages';
+import type { ScannedRoute } from '../src/compiler/routes';
+
+const dirs: string[] = [];
+/** Writes a throwaway routes dir with the given `{ relPath: source }` files, returns its path. */
+function tmpRoutes(files: Record<string, string>): string {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'toil-pages-'));
+    dirs.push(dir);
+    for (const [rel, src] of Object.entries(files)) {
+        const full = path.join(dir, rel);
+        fs.mkdirSync(path.dirname(full), { recursive: true });
+        fs.writeFileSync(full, src);
+    }
+    return dir;
+}
+function route(
+    dir: string,
+    file: string,
+    pattern: string,
+    extra: Partial<ScannedRoute> = {},
+): ScannedRoute {
+    return { file: path.join(dir, file), pattern, ...extra };
+}
+
+afterEach(() => {
+    for (const d of dirs.splice(0)) fs.rmSync(d, { recursive: true, force: true });
+});
+
+describe('buildPageIndex', () => {
+    it('extracts each page metadata and flags dynamic routes', () => {
+        const dir = tmpRoutes({
+            'index.tsx': `export const metadata = { title: 'Home' };\nexport default () => null;\n`,
+            'blog/[id].tsx': `export const metadata = { title: 'Post' };\nexport default () => null;\n`,
+        });
+        const pages = buildPageIndex(process.cwd(), [
+            route(dir, 'index.tsx', '/'),
+            route(dir, 'blog/[id].tsx', '/blog/:id'),
+        ]);
+        expect(pages).toEqual([
+            { path: '/', dynamic: false, metadata: { title: 'Home' } },
+            { path: '/blog/:id', dynamic: true, metadata: { title: 'Post' } },
+        ]);
+    });
+
+    it('merges searchHints over static metadata (hints win) for dynamic discoverability', () => {
+        const dir = tmpRoutes({
+            'blog/[id].tsx':
+                `export const searchHints = { title: 'Blog', keywords: ['posts', 'articles'] };\n` +
+                `export const generateMetadata = ({ params }) => ({ title: params.id });\n` +
+                `export default () => null;\n`,
+        });
+        const [page] = buildPageIndex(process.cwd(), [route(dir, 'blog/[id].tsx', '/blog/:id')]);
+        expect(page).toEqual({
+            path: '/blog/:id',
+            dynamic: true,
+            metadata: { title: 'Blog', keywords: ['posts', 'articles'] },
+        });
+    });
+
+    it('uses an empty metadata object when a route declares none', () => {
+        const dir = tmpRoutes({ 'about.tsx': `export default () => null;\n` });
+        const pages = buildPageIndex(process.cwd(), [route(dir, 'about.tsx', '/about')]);
+        expect(pages).toEqual([{ path: '/about', dynamic: false, metadata: {} }]);
+    });
+
+    it('excludes slots and intercepting routes, and dedupes patterns', () => {
+        const dir = tmpRoutes({
+            'index.tsx': `export const metadata = { title: 'Home' };\nexport default () => null;\n`,
+            '@modal/photo.tsx': `export default () => null;\n`,
+            '(.)photo.tsx': `export default () => null;\n`,
+        });
+        const pages = buildPageIndex(process.cwd(), [
+            route(dir, 'index.tsx', '/'),
+            route(dir, '@modal/photo.tsx', '/photo', { slot: 'modal' }),
+            route(dir, '(.)photo.tsx', '/photo', { intercept: true }),
+        ]);
+        expect(pages.map((p) => p.path)).toEqual(['/']);
+    });
+
+    it('sorts the index by path for deterministic output', () => {
+        const dir = tmpRoutes({
+            'zed.tsx': `export default () => null;\n`,
+            'about.tsx': `export default () => null;\n`,
+        });
+        const pages = buildPageIndex(process.cwd(), [
+            route(dir, 'zed.tsx', '/zed'),
+            route(dir, 'about.tsx', '/about'),
+        ]);
+        expect(pages.map((p) => p.path)).toEqual(['/about', '/zed']);
+    });
+});
+
+describe('pagesModuleSource', () => {
+    it('emits a typed pages export with JSON-serialized entries', () => {
+        const src = pagesModuleSource([{ path: '/', dynamic: false, metadata: { title: 'Home' } }]);
+        expect(src).toContain('export const pages: PageMeta[] = [');
+        expect(src).toContain('{"path":"/","dynamic":false,"metadata":{"title":"Home"}}');
+    });
+});

package/test/prerender.test.ts

@@ -1,46 +1,54 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import ts from 'typescript';
-import { afterEach, describe, expect, it } from 'vitest';
-
-import { extractStaticMetadata } from '../src/compiler/prerender';
-
-const written: string[] = [];
-function tmp(source: string): string {
-    const file = path.join(os.tmpdir(), `toil-prerender-${String(written.length)}-${process.pid}.tsx`);
-    fs.writeFileSync(file, source);
-    written.push(file);
-    return file;
-}
-afterEach(() => {
-    for (const f of written.splice(0)) fs.rmSync(f, { force: true });
-});
-
-describe('extractStaticMetadata', () => {
-    it('extracts a static metadata object literal (nested objects/arrays)', () => {
-        const file = tmp(
-            `export const metadata = { title: 'X', keywords: ['a', 'b'], openGraph: { type: 'website' } };\n` +
-                `export default function P() { return null; }\n`,
-        );
-        expect(extractStaticMetadata(ts, file)).toEqual({
-            title: 'X',
-            keywords: ['a', 'b'],
-            openGraph: { type: 'website' },
-        });
-    });
-
-    it('returns null when there is no static metadata export', () => {
-        expect(extractStaticMetadata(ts, tmp(`export default function P() { return null; }\n`))).toBeNull();
-        // generateMetadata (a function) is not a static object literal → not extracted.
-        expect(
-            extractStaticMetadata(ts, tmp(`export const generateMetadata = () => ({ title: 'X' });\n`)),
-        ).toBeNull();
-    });
-
-    it('skips computed/non-literal properties but keeps the static ones', () => {
-        const file = tmp(`const x = foo();\nexport const metadata = { title: 'X', dyn: x };\n`);
-        expect(extractStaticMetadata(ts, file)).toEqual({ title: 'X' });
-    });
-});
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import ts from 'typescript';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { extractStaticMetadata } from '../src/compiler/prerender';
+
+const written: string[] = [];
+function tmp(source: string): string {
+    const file = path.join(
+        os.tmpdir(),
+        `toil-prerender-${String(written.length)}-${process.pid}.tsx`,
+    );
+    fs.writeFileSync(file, source);
+    written.push(file);
+    return file;
+}
+afterEach(() => {
+    for (const f of written.splice(0)) fs.rmSync(f, { force: true });
+});
+
+describe('extractStaticMetadata', () => {
+    it('extracts a static metadata object literal (nested objects/arrays)', () => {
+        const file = tmp(
+            `export const metadata = { title: 'X', keywords: ['a', 'b'], openGraph: { type: 'website' } };\n` +
+                `export default function P() { return null; }\n`,
+        );
+        expect(extractStaticMetadata(ts, file)).toEqual({
+            title: 'X',
+            keywords: ['a', 'b'],
+            openGraph: { type: 'website' },
+        });
+    });
+
+    it('returns null when there is no static metadata export', () => {
+        expect(
+            extractStaticMetadata(ts, tmp(`export default function P() { return null; }\n`)),
+        ).toBeNull();
+        // generateMetadata (a function) is not a static object literal → not extracted.
+        expect(
+            extractStaticMetadata(
+                ts,
+                tmp(`export const generateMetadata = () => ({ title: 'X' });\n`),
+            ),
+        ).toBeNull();
+    });
+
+    it('skips computed/non-literal properties but keeps the static ones', () => {
+        const file = tmp(`const x = foo();\nexport const metadata = { title: 'X', dyn: x };\n`);
+        expect(extractStaticMetadata(ts, file)).toEqual({ title: 'X' });
+    });
+});

package/test/search.test.ts

@@ -0,0 +1,114 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import {
+    getPages,
+    type PageMeta,
+    pagePath,
+    registerPages,
+    searchPages,
+} from '../src/client/search/search';
+
+const PAGES: PageMeta[] = [
+    {
+        path: '/',
+        dynamic: false,
+        metadata: { title: 'Home', description: 'Welcome to the toil demo site' },
+    },
+    {
+        path: '/about',
+        dynamic: false,
+        metadata: { title: 'About', description: 'Who we are', keywords: ['team', 'company'] },
+    },
+    {
+        path: '/blog',
+        dynamic: false,
+        metadata: {
+            title: 'Blog',
+            description: 'Articles and updates',
+            openGraph: { title: 'The Blog', siteName: 'toil' },
+        },
+    },
+    { path: '/blog/:id', dynamic: true, metadata: { title: 'Blog post' } },
+    { path: '/get-started', dynamic: false, metadata: {} },
+];
+
+beforeEach(() => {
+    registerPages(PAGES);
+});
+
+describe('searchPages', () => {
+    it('returns no results for an empty / whitespace query', () => {
+        expect(searchPages('')).toEqual([]);
+        expect(searchPages('   ')).toEqual([]);
+    });
+
+    it('ranks a title match above a description-only match', () => {
+        const results = searchPages('about');
+        expect(results[0].page.path).toBe('/about');
+        // Two pages mention "about"? Only /about does here; the home page does not.
+        expect(results.map((r) => r.page.path)).toContain('/about');
+        expect(results[0].matches).toContain('title');
+    });
+
+    it('matches keywords', () => {
+        const results = searchPages('team');
+        expect(results).toHaveLength(1);
+        expect(results[0].page.path).toBe('/about');
+        expect(results[0].matches).toContain('keywords');
+    });
+
+    it('matches OpenGraph fields', () => {
+        const results = searchPages('blog', { fields: ['openGraph'] });
+        expect(results.map((r) => r.page.path)).toEqual(['/blog']);
+        expect(results[0].matches).toEqual(['openGraph']);
+    });
+
+    it('makes slugs word-searchable via the path field', () => {
+        const results = searchPages('started');
+        expect(results.map((r) => r.page.path)).toContain('/get-started');
+    });
+
+    it('excludes dynamic routes unless includeDynamic is set', () => {
+        expect(searchPages('post').map((r) => r.page.path)).not.toContain('/blog/:id');
+        expect(searchPages('post', { includeDynamic: true }).map((r) => r.page.path)).toContain(
+            '/blog/:id',
+        );
+    });
+
+    it('uses AND semantics: every term must match', () => {
+        expect(searchPages('blog updates').map((r) => r.page.path)).toEqual(['/blog']);
+        expect(searchPages('blog nonexistentword')).toEqual([]);
+    });
+
+    it('honors the limit option', () => {
+        // "toil" appears in the home description and the blog's OpenGraph siteName.
+        const all = searchPages('toil');
+        expect(all.length).toBeGreaterThan(1);
+        expect(searchPages('toil', { limit: 1 })).toHaveLength(1);
+    });
+
+    it('restricts matching to the requested fields', () => {
+        // "welcome" only lives in the home description; excluding it yields nothing.
+        expect(searchPages('welcome', { fields: ['title', 'keywords'] })).toEqual([]);
+        expect(searchPages('welcome', { fields: ['description'] }).map((r) => r.page.path)).toEqual(
+            ['/'],
+        );
+    });
+
+    it('is case-insensitive', () => {
+        expect(searchPages('ABOUT')[0].page.path).toBe('/about');
+    });
+});
+
+describe('registry helpers', () => {
+    it('getPages returns the registered index', () => {
+        expect(getPages()).toBe(PAGES);
+    });
+
+    it('pagePath normalizes results, pages, and raw strings', () => {
+        const result = searchPages('about')[0];
+        expect(pagePath(result)).toBe('/about');
+        expect(pagePath(result.page)).toBe('/about');
+        expect(pagePath('/raw')).toBe('/raw');
+    });
+});

package/test/seo.test.ts

@@ -1,142 +1,164 @@
-import { describe, expect, it } from 'vitest';
-
-import type { ScannedRoute } from '../src/compiler/routes';
-import { injectSeoHtml, llmsTxt, robotsTxt, routeSeo, seoHeadTags, sitemapXml } from '../src/compiler/seo';
-
-const routes: ScannedRoute[] = [
-    { file: 'a', pattern: '/' },
-    { file: 'b', pattern: '/about' },
-    { file: 'c', pattern: '/blog/:id' }, // dynamic — excluded from sitemap
-    { file: 'd', pattern: '/photo/:id', slot: 'modal', intercept: true }, // slot/intercept — excluded
-];
-
-describe('seoHeadTags', () => {
-    it('bakes description, OG, canonical, preconnect, and JSON-LD', () => {
-        const html = seoHeadTags({
-            url: 'https://x.test',
-            title: 'Home',
-            description: 'desc',
-            openGraph: { type: 'website', image: 'https://x.test/og.png' },
-            preconnect: ['https://cdn.test'],
-            jsonLd: { '@context': 'https://schema.org', '@type': 'WebSite' },
-        });
-        expect(html).toContain('<meta name="description" content="desc" />');
-        expect(html).toContain('<meta property="og:title" content="Home" />');
-        expect(html).toContain('<meta property="og:image" content="https://x.test/og.png" />');
-        expect(html).toContain('<link rel="canonical" href="https://x.test" />');
-        expect(html).toContain('<link rel="preconnect" href="https://cdn.test" />');
-        expect(html).toContain('application/ld+json');
-        expect(html).toContain('"@type":"WebSite"');
-    });
-
-    it('escapes attribute values', () => {
-        expect(seoHeadTags({ description: 'a "b" <c>' })).toContain('content="a &quot;b&quot; &lt;c&gt;"');
-    });
-
-    it('renders a full Twitter card + OG image dimensions + fb:app_id', () => {
-        const html = seoHeadTags({
-            title: 'Home',
-            description: 'd',
-            openGraph: { image: 'https://x.test/og.png', imageAlt: 'alt', imageWidth: 1200, imageHeight: 630 },
-            twitter: { site: '@x' },
-            facebook: { appId: '123' },
-        });
-        expect(html).toContain('<meta name="twitter:card" content="summary_large_image" />');
-        expect(html).toContain('<meta name="twitter:site" content="@x" />');
-        expect(html).toContain('<meta name="twitter:title" content="Home" />');
-        expect(html).toContain('<meta name="twitter:image" content="https://x.test/og.png" />');
-        expect(html).toContain('<meta property="og:image:width" content="1200" />');
-        expect(html).toContain('<meta property="og:image:alt" content="alt" />');
-        expect(html).toContain('<meta property="fb:app_id" content="123" />');
-    });
-
-    it('neutralizes </script> in JSON-LD (no script breakout)', () => {
-        const html = seoHeadTags({ jsonLd: { x: '</script><img src=x onerror=alert(1)>' } });
-        expect(html).not.toContain('</script><img');
-        expect(html).toContain('\\u003c/script');
-    });
-});
-
-describe('routeSeo', () => {
-    it("overlays a route's metadata over the site defaults and points URLs at the route", () => {
-        const site = { url: 'https://x.test', title: 'Site', description: 'site desc' };
-        const out = routeSeo(site, { title: 'About', description: 'about desc' }, '/about');
-        expect(out.title).toBe('About');
-        expect(out.description).toBe('about desc');
-        expect(out.url).toBe('https://x.test/about');
-    });
-
-    it('falls back to the site defaults when a route has no metadata', () => {
-        const site = { url: 'https://x.test', title: 'Site' };
-        expect(routeSeo(site, null, '/x')).toMatchObject({ title: 'Site', url: 'https://x.test/x' });
-    });
-});
-
-describe('injectSeoHtml', () => {
-    it('replaces the title + description and inserts the rest before </head>', () => {
-        const shell = '<!doctype html><html><head><title>old</title><meta name="description" content="" /></head><body></body></html>';
-        const out = injectSeoHtml(shell, { title: 'New', description: 'fresh', url: 'https://x.test' });
-        expect(out).toContain('<title>New</title>');
-        expect(out).not.toContain('<title>old</title>');
-        expect(out.match(/name="description"/g)).toHaveLength(1);
-        expect(out).toContain('content="fresh"');
-        expect(out).toContain('<link rel="canonical" href="https://x.test" />');
-    });
-});
-
-describe('robotsTxt', () => {
-    it('allows all + lists AI crawlers + links the sitemap by default', () => {
-        const txt = robotsTxt({ url: 'https://x.test' });
-        expect(txt).toContain('User-agent: *');
-        expect(txt).toContain('Allow: /');
-        expect(txt).toContain('User-agent: GPTBot');
-        expect(txt).toContain('User-agent: ClaudeBot');
-        expect(txt).toContain('Sitemap: https://x.test/sitemap.xml');
-    });
-
-    it('disallows AI crawlers when ai: "disallow"', () => {
-        const txt = robotsTxt({ url: 'https://x.test', robots: { ai: 'disallow' } });
-        expect(txt).toMatch(/User-agent: GPTBot\nDisallow: \//);
-    });
-
-    it('is empty when robots: false', () => {
-        expect(robotsTxt({ robots: false })).toBe('');
-    });
-});
-
-describe('sitemapXml', () => {
-    it('lists only static routes, absolute', () => {
-        const xml = sitemapXml({ url: 'https://x.test' }, routes);
-        expect(xml).toContain('<loc>https://x.test</loc>');
-        expect(xml).toContain('<loc>https://x.test/about</loc>');
-        expect(xml).not.toContain(':id');
-        expect(xml).not.toContain('/photo');
-    });
-
-    it('is empty without a base url', () => {
-        expect(sitemapXml({}, routes)).toBe('');
-    });
-});
-
-describe('llmsTxt', () => {
-    it('renders title, summary, instructions, and pages', () => {
-        const txt = llmsTxt(
-            {
-                url: 'https://x.test',
-                title: 'My Site',
-                description: 'a site',
-                llms: { instructions: 'Be nice.' },
-            },
-            routes,
-        );
-        expect(txt).toContain('# My Site');
-        expect(txt).toContain('> a site');
-        expect(txt).toContain('Be nice.');
-        expect(txt).toContain('[Home](https://x.test)');
-        expect(txt).toContain('[/about](https://x.test/about)');
-    });
-
-    it('is empty when llms: false', () => {
-        expect(llmsTxt({ llms: false }, routes)).toBe('');
-    });
-});
+import { describe, expect, it } from 'vitest';
+
+import type { ScannedRoute } from '../src/compiler/routes';
+import {
+    injectSeoHtml,
+    llmsTxt,
+    robotsTxt,
+    routeSeo,
+    seoHeadTags,
+    sitemapXml,
+} from '../src/compiler/seo';
+
+const routes: ScannedRoute[] = [
+    { file: 'a', pattern: '/' },
+    { file: 'b', pattern: '/about' },
+    { file: 'c', pattern: '/blog/:id' }, // dynamic — excluded from sitemap
+    { file: 'd', pattern: '/photo/:id', slot: 'modal', intercept: true }, // slot/intercept — excluded
+];
+
+describe('seoHeadTags', () => {
+    it('bakes description, OG, canonical, preconnect, and JSON-LD', () => {
+        const html = seoHeadTags({
+            url: 'https://x.test',
+            title: 'Home',
+            description: 'desc',
+            openGraph: { type: 'website', image: 'https://x.test/og.png' },
+            preconnect: ['https://cdn.test'],
+            jsonLd: { '@context': 'https://schema.org', '@type': 'WebSite' },
+        });
+        expect(html).toContain('<meta name="description" content="desc" />');
+        expect(html).toContain('<meta property="og:title" content="Home" />');
+        expect(html).toContain('<meta property="og:image" content="https://x.test/og.png" />');
+        expect(html).toContain('<link rel="canonical" href="https://x.test" />');
+        expect(html).toContain('<link rel="preconnect" href="https://cdn.test" />');
+        expect(html).toContain('application/ld+json');
+        expect(html).toContain('"@type":"WebSite"');
+    });
+
+    it('escapes attribute values', () => {
+        expect(seoHeadTags({ description: 'a "b" <c>' })).toContain(
+            'content="a &quot;b&quot; &lt;c&gt;"',
+        );
+    });
+
+    it('renders a full Twitter card + OG image dimensions + fb:app_id', () => {
+        const html = seoHeadTags({
+            title: 'Home',
+            description: 'd',
+            openGraph: {
+                image: 'https://x.test/og.png',
+                imageAlt: 'alt',
+                imageWidth: 1200,
+                imageHeight: 630,
+            },
+            twitter: { site: '@x' },
+            facebook: { appId: '123' },
+        });
+        expect(html).toContain('<meta name="twitter:card" content="summary_large_image" />');
+        expect(html).toContain('<meta name="twitter:site" content="@x" />');
+        expect(html).toContain('<meta name="twitter:title" content="Home" />');
+        expect(html).toContain('<meta name="twitter:image" content="https://x.test/og.png" />');
+        expect(html).toContain('<meta property="og:image:width" content="1200" />');
+        expect(html).toContain('<meta property="og:image:alt" content="alt" />');
+        expect(html).toContain('<meta property="fb:app_id" content="123" />');
+    });
+
+    it('neutralizes </script> in JSON-LD (no script breakout)', () => {
+        const html = seoHeadTags({ jsonLd: { x: '</script><img src=x onerror=alert(1)>' } });
+        expect(html).not.toContain('</script><img');
+        expect(html).toContain('\\u003c/script');
+    });
+});
+
+describe('routeSeo', () => {
+    it("overlays a route's metadata over the site defaults and points URLs at the route", () => {
+        const site = { url: 'https://x.test', title: 'Site', description: 'site desc' };
+        const out = routeSeo(site, { title: 'About', description: 'about desc' }, '/about');
+        expect(out.title).toBe('About');
+        expect(out.description).toBe('about desc');
+        expect(out.url).toBe('https://x.test/about');
+    });
+
+    it('falls back to the site defaults when a route has no metadata', () => {
+        const site = { url: 'https://x.test', title: 'Site' };
+        expect(routeSeo(site, null, '/x')).toMatchObject({
+            title: 'Site',
+            url: 'https://x.test/x',
+        });
+    });
+});
+
+describe('injectSeoHtml', () => {
+    it('replaces the title + description and inserts the rest before </head>', () => {
+        const shell =
+            '<!doctype html><html><head><title>old</title><meta name="description" content="" /></head><body></body></html>';
+        const out = injectSeoHtml(shell, {
+            title: 'New',
+            description: 'fresh',
+            url: 'https://x.test',
+        });
+        expect(out).toContain('<title>New</title>');
+        expect(out).not.toContain('<title>old</title>');
+        expect(out.match(/name="description"/g)).toHaveLength(1);
+        expect(out).toContain('content="fresh"');
+        expect(out).toContain('<link rel="canonical" href="https://x.test" />');
+    });
+});
+
+describe('robotsTxt', () => {
+    it('allows all + lists AI crawlers + links the sitemap by default', () => {
+        const txt = robotsTxt({ url: 'https://x.test' });
+        expect(txt).toContain('User-agent: *');
+        expect(txt).toContain('Allow: /');
+        expect(txt).toContain('User-agent: GPTBot');
+        expect(txt).toContain('User-agent: ClaudeBot');
+        expect(txt).toContain('Sitemap: https://x.test/sitemap.xml');
+    });
+
+    it('disallows AI crawlers when ai: "disallow"', () => {
+        const txt = robotsTxt({ url: 'https://x.test', robots: { ai: 'disallow' } });
+        expect(txt).toMatch(/User-agent: GPTBot\nDisallow: \//);
+    });
+
+    it('is empty when robots: false', () => {
+        expect(robotsTxt({ robots: false })).toBe('');
+    });
+});
+
+describe('sitemapXml', () => {
+    it('lists only static routes, absolute', () => {
+        const xml = sitemapXml({ url: 'https://x.test' }, routes);
+        expect(xml).toContain('<loc>https://x.test</loc>');
+        expect(xml).toContain('<loc>https://x.test/about</loc>');
+        expect(xml).not.toContain(':id');
+        expect(xml).not.toContain('/photo');
+    });
+
+    it('is empty without a base url', () => {
+        expect(sitemapXml({}, routes)).toBe('');
+    });
+});
+
+describe('llmsTxt', () => {
+    it('renders title, summary, instructions, and pages', () => {
+        const txt = llmsTxt(
+            {
+                url: 'https://x.test',
+                title: 'My Site',
+                description: 'a site',
+                llms: { instructions: 'Be nice.' },
+            },
+            routes,
+        );
+        expect(txt).toContain('# My Site');
+        expect(txt).toContain('> a site');
+        expect(txt).toContain('Be nice.');
+        expect(txt).toContain('[Home](https://x.test)');
+        expect(txt).toContain('[/about](https://x.test/about)');
+    });
+
+    it('is empty when llms: false', () => {
+        expect(llmsTxt({ llms: false }, routes)).toBe('');
+    });
+});