@ultimat3/cli 22.2.1 → 22.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/cli",
-  "version": "22.2.1",
+  "version": "22.2.2",
   "description": "The `x` binary: new, dev, build, verify, generate, db, mcp, doctor, deploy",
   "license": "MIT",
   "type": "module",
@@ -38,33 +38,33 @@
   },
   "dependencies": {
     "@babel/core": "^8.0.1",
-    "@ultimat3/action": "22.2.1",
-    "@ultimat3/admin": "22.2.1",
-    "@ultimat3/ai": "22.2.1",
-    "@ultimat3/auth": "22.2.1",
-    "@ultimat3/cache": "22.2.1",
-    "@ultimat3/core": "22.2.1",
-    "@ultimat3/db": "22.2.1",
-    "@ultimat3/entity": "22.2.1",
-    "@ultimat3/flags": "22.2.1",
-    "@ultimat3/http": "22.2.1",
-    "@ultimat3/i18n": "22.2.1",
-    "@ultimat3/jobs": "22.2.1",
-    "@ultimat3/mail": "22.2.1",
-    "@ultimat3/manifest": "22.2.1",
-    "@ultimat3/mcp": "22.2.1",
-    "@ultimat3/money": "22.2.1",
-    "@ultimat3/notify": "22.2.1",
-    "@ultimat3/policy": "22.2.1",
-    "@ultimat3/pwa": "22.2.1",
-    "@ultimat3/query": "22.2.1",
-    "@ultimat3/realtime": "22.2.1",
-    "@ultimat3/render": "22.2.1",
-    "@ultimat3/schema": "22.2.1",
-    "@ultimat3/seo": "22.2.1",
-    "@ultimat3/storage": "22.2.1",
-    "@ultimat3/testing": "22.2.1",
-    "@ultimat3/time": "22.2.1",
+    "@ultimat3/action": "22.2.2",
+    "@ultimat3/admin": "22.2.2",
+    "@ultimat3/ai": "22.2.2",
+    "@ultimat3/auth": "22.2.2",
+    "@ultimat3/cache": "22.2.2",
+    "@ultimat3/core": "22.2.2",
+    "@ultimat3/db": "22.2.2",
+    "@ultimat3/entity": "22.2.2",
+    "@ultimat3/flags": "22.2.2",
+    "@ultimat3/http": "22.2.2",
+    "@ultimat3/i18n": "22.2.2",
+    "@ultimat3/jobs": "22.2.2",
+    "@ultimat3/mail": "22.2.2",
+    "@ultimat3/manifest": "22.2.2",
+    "@ultimat3/mcp": "22.2.2",
+    "@ultimat3/money": "22.2.2",
+    "@ultimat3/notify": "22.2.2",
+    "@ultimat3/policy": "22.2.2",
+    "@ultimat3/pwa": "22.2.2",
+    "@ultimat3/query": "22.2.2",
+    "@ultimat3/realtime": "22.2.2",
+    "@ultimat3/render": "22.2.2",
+    "@ultimat3/schema": "22.2.2",
+    "@ultimat3/seo": "22.2.2",
+    "@ultimat3/storage": "22.2.2",
+    "@ultimat3/testing": "22.2.2",
+    "@ultimat3/time": "22.2.2",
     "babel-preset-solid": "^1.9.15"
   }
 }

package/src/api-registration.ts

@@ -34,14 +34,27 @@ export function apiEntriesFor(written: readonly string[]): readonly ApiEntry[] {
   });
 }
 
-/** Every `[...]` entry of a `key: [...]` list in the `defineApi({ ... })` call. */
+/**
+ * Every `[...]` entry of a `key: [...]` list in the `defineApi({ ... })` call, and where it sits:
+ * `line` is the start of the line holding `key: [`, `start` is just past the `[`, `end` is the `]`.
+ *
+ * Searched from `from` (the `defineApi({` call), so a `jobs: [` in a comment or an object above the
+ * call is never the one edited. `line` is found from the key, never from `start`: in a list already
+ * wrapped one entry per line the character AT `start` is the newline after `[`, and a backwards
+ * search from there answered the first ITEM's line — the rewrite then nested a second `jobs: [`
+ * inside the first and left the old `]` behind.
+ */
 const listOf = (
   source: string,
   key: string,
-): { start: number; end: number; items: string[] } | undefined => {
-  const open = new RegExp(`\\n(\\s*)${key}: \\[`).exec(source);
-  if (open === null) return undefined;
-  const start = open.index + open[0].length;
+  from: number,
+): { line: number; start: number; end: number; items: string[] } | undefined => {
+  const open = new RegExp(`\\n([ \\t]*)${key}: \\[`, 'g');
+  open.lastIndex = from;
+  const found = open.exec(source);
+  if (found === null) return undefined;
+  const line = found.index + 1;
+  const start = found.index + found[0].length;
   const end = source.indexOf(']', start);
   if (end === -1) return undefined;
   const items = source
@@ -49,7 +62,7 @@ const listOf = (
     .split(',')
     .map((item) => item.trim())
     .filter((item) => item.length > 0);
-  return { start, end, items };
+  return { line, start, end, items };
 };
 
 /**
@@ -68,12 +81,12 @@ export function insertApiEntries(
   for (const entry of entries) {
     const importLine = `import * as ${entry.binding} from '${entry.specifier}';`;
     const call = next.indexOf('defineApi({');
-    const actions = listOf(next, 'actions');
+    const actions = call === -1 ? undefined : listOf(next, 'actions', call);
     if (call === -1 || actions === undefined) {
       skipped.push(entry);
       continue;
     }
-    const list = listOf(next, entry.key);
+    const list = listOf(next, entry.key, call);
     if (list?.items.includes(entry.binding) === true) continue;
     if (list === undefined) {
       // After `actions: [...],` — the order `x new` writes: actions, queries, jobs, tasks.
@@ -82,10 +95,9 @@ export function insertApiEntries(
       next = `${next.slice(0, after + 1)}${line}\n${next.slice(after + 1)}`;
     } else {
       const items = [...list.items, entry.binding];
-      const lineStart = next.lastIndexOf('\n', list.start) + 1;
-      const indent = /^\s*/.exec(next.slice(lineStart))?.[0] ?? '';
+      const indent = /^[ \t]*/.exec(next.slice(list.line))?.[0] ?? '';
       const rewritten = wrapList(indent, `${entry.key}: [`, items, ']');
-      next = `${next.slice(0, lineStart)}${rewritten}${next.slice(list.end + 1)}`;
+      next = `${next.slice(0, list.line)}${rewritten}${next.slice(list.end + 1)}`;
     }
     if (!next.includes(importLine)) next = withImport(next, importLine);
   }

package/src/cmd-dev.ts

@@ -223,6 +223,7 @@ async function bootDev(
     storage: runtime.storage,
     dashboard,
     islands: () => state.islands,
+    realtime: runtime.realtime,
   });
 
   // The app's `apps/<app>/runtime.ts`, composed exactly as `runRole` composes a caller's

package/src/dev-route-table.ts

@@ -2,6 +2,7 @@
 // names, the island and sync-worker scripts, and the app's pages last. Split from `cmd-dev.ts` at its
 // 500-line ceiling; `serve.ts` composes the production table from the same builders.
 
+import type { RealtimeConfig } from '@ultimat3/core';
 import type { Route } from '@ultimat3/http';
 import { describeRoutes } from '@ultimat3/render';
 import type { Storage } from '@ultimat3/storage';
@@ -19,6 +20,7 @@ import { loadPwaArtifacts } from './pwa-artifacts';
 import { assetRoutes } from './runtime-assets';
 import { appRoutes } from './runtime-render';
 import { servedStorage, storageRoutes } from './runtime-storage';
+import { seoRoutes } from './seo-routes';
 import { styleBundle } from './style-bundle';
 import { styleRoutes } from './style-routes';
 import { serviceWorkerArtifacts } from './sw-artifacts';
@@ -34,6 +36,8 @@ export interface DevRouteTableInput {
   readonly dashboard: DevDashboardInput;
   /** A getter: the watcher tick rebuilds the islands, and a captured bundle would serve the first. */
   readonly islands: () => IslandBundle;
+  /** `app.config.ts`'s `realtime`, as the boot obeyed it: off, no document names a sync node. */
+  readonly realtime: Pick<RealtimeConfig, 'enabled'>;
 }
 
 export interface DevRouteTable {
@@ -52,7 +56,7 @@ export async function devRouteTable(input: DevRouteTableInput): Promise<DevRoute
   const pwa = await loadPwaArtifacts(input.root);
   const theme = themeBoot(await loadThemeMode(input.root));
   // The same call `serve.ts` makes, so the two boots cannot serve different sync targets.
-  const sync = await pageSync(input.root, input.env, input.buildId);
+  const sync = await pageSync(input.root, input.env, input.buildId, input.realtime);
   const errorStyles = await errorPageStyleSources(input.root);
   // Built once at boot and NOT rebuilt with the islands on a watcher tick: a service worker that
   // changes under a page it controls is the update path, and one per keystroke exercises it per save.
@@ -96,6 +100,8 @@ export async function devRouteTable(input: DevRouteTableInput): Promise<DevRoute
     // reason the islands are: a rebuilt island registers CSS, which mints a new URL, and a table
     // captured at boot would answer 404 for the href the document now carries.
     ...styleRoutes(() => styleBundle()),
+    // `robots.txt` and `sitemap.xml`, the same two files the static export writes (`site-seo.ts`).
+    ...seoRoutes({ env: input.env }),
     // `x shot --island`'s harness, in the `/_x` dev namespace so no app route can shadow it. It
     // lives here rather than in a second server because everything it needs is in THIS process:
     // the built chunks, the app's stylesheet registry, and the one embedded Postgres a checkout
@@ -110,7 +116,7 @@ export async function devRouteTable(input: DevRouteTableInput): Promise<DevRoute
     ...appRoutes({
       buildId: input.buildId,
       resolveIsland: (file) => input.islands().resolverFor(file),
-      sync: sync.head,
+      ...(sync.head === undefined ? {} : { sync: sync.head }),
       persisted: sync.persisted,
       themeHead: theme.head,
       ...(pwa === undefined ? {} : { pwaHead: pwa.head + (serviceWorker?.head ?? '') }),

package/src/index.ts

@@ -145,6 +145,8 @@ export {
   serveApp,
 } from './serve';
 export { quoteArg } from './shell-quote';
+export type { SiteSeo, SiteSeoOptions } from './site-seo';
+export { ROBOTS_PATH, SITEMAP_PATH, siteSeo } from './site-seo';
 export { eachSourceFile, isGenerated, isTest, SOURCE_GLOBS } from './source-files';
 export type { SkippedRoute, StaticReport } from './static-report';
 export { parseStaticReport } from './static-report';

package/src/page-sync.ts

@@ -3,6 +3,7 @@
 // `ultimate-build`, `ultimate-sync-worker`, the boot script), and the persisted record types a
 // private document names. One call from both boots, so the two cannot serve different targets.
 
+import type { RealtimeConfig } from '@ultimat3/core';
 import { persistedRecordTypes } from '@ultimat3/entity';
 import type { Route } from '@ultimat3/http';
 import type { ClientSyncHead } from '@ultimat3/render';
@@ -19,7 +20,11 @@ export interface PageSync {
   readonly routes: readonly Route[];
   /** The scripts those routes serve, for the service worker to precache beside the islands. */
   readonly scripts: readonly FrameworkScript[];
-  readonly head: ClientSyncHead;
+  /**
+   * `undefined` when `realtime.enabled` is false: no node is started (`role-realtime.ts`), so a
+   * document naming one would hand the page runtime a target nothing serves.
+   */
+  readonly head: ClientSyncHead | undefined;
   /**
    * The record types the app persists, read per render off the entity registry — the app's modules
    * register their entities during boot, so a value captured here could predate them.
@@ -36,7 +41,13 @@ export async function pageSync(
   root: string,
   env: Readonly<Record<string, string | undefined>>,
   buildId: string,
+  realtime: Pick<RealtimeConfig, 'enabled'>,
 ): Promise<PageSync> {
+  // Off: no `ultimate-sync`, no worker, no boot script — the boot is the outbox and the disk
+  // restore, which exist to feed the socket. Checked before either build, which would be wasted.
+  if (!realtime.enabled) {
+    return { routes: [], scripts: [], head: undefined, persisted: persistedRecordTypes };
+  }
   const syncUrl = syncUrlFrom(env);
   const worker = await buildSyncWorker(root);
   const boot = await buildPageBoot(root);

package/src/seo-routes.ts

@@ -0,0 +1,67 @@
+// `GET /robots.txt` and `GET /sitemap.xml` from a running web role — the files the static export
+// writes, answered by the process for a deploy that serves its pages from a container. Mounted by
+// `x dev` and `runRole` alike, before the app's pages, for `style-routes.ts`' reason.
+
+import { DEFAULT_ENVIRONMENT, type Environment, tryResolveEnvironment } from '@ultimat3/core';
+import type { Route, UltimateRequest } from '@ultimat3/http';
+import { applyCacheHeaders } from '@ultimat3/http';
+import { ROBOTS_PATH, SITEMAP_PATH, siteSeo } from './site-seo';
+
+export interface SeoRoutesOptions {
+  readonly env: Readonly<Record<string, string | undefined>>;
+}
+
+/**
+ * The public origin: `APP_URL`, the one the framework's runtime already names for it (OAuth's
+ * redirect, the sync node's admitted origin); else `SITE_ORIGIN`, the static build's; else the
+ * request's own. A container behind an ingress sees its pod address as the request's host, which
+ * is why the declared origin comes first — a sitemap of `http://10.0.0.7:3000/…` indexes nothing.
+ */
+function originOf(env: SeoRoutesOptions['env'], request: UltimateRequest): string {
+  for (const key of ['APP_URL', 'SITE_ORIGIN']) {
+    const declared = env[key]?.trim() ?? '';
+    if (declared !== '') return declared.replace(/\/+$/, '');
+  }
+  return new URL(request.url).origin;
+}
+
+/**
+ * Per request, never cached across one: `prerender()` may enumerate rows that change, and a
+ * crawler asks for these a handful of times a day. An hour of shared cache is what a CDN keeps.
+ */
+const SEO_CACHE = { mode: 'public', maxAgeSeconds: 3600 } as const;
+
+export function seoRoutes(options: SeoRoutesOptions): readonly Route[] {
+  const environment: Environment =
+    tryResolveEnvironment({ env: options.env }) ?? DEFAULT_ENVIRONMENT;
+  const answer = async (request: UltimateRequest) =>
+    await siteSeo({ baseUrl: originOf(options.env, request), environment });
+
+  return [
+    {
+      method: 'GET',
+      path: ROBOTS_PATH,
+      meta: { name: 'seo.robots', auth: 'public', tags: ['seo'] },
+      handler: async (request: UltimateRequest): Promise<Response> =>
+        applyCacheHeaders(
+          new Response((await answer(request)).robots, {
+            headers: { 'content-type': 'text/plain; charset=utf-8' },
+          }),
+          SEO_CACHE,
+        ),
+    },
+    {
+      method: 'GET',
+      path: SITEMAP_PATH,
+      meta: { name: 'seo.sitemap', auth: 'public', tags: ['seo'] },
+      // The first file is `/sitemap.xml` in both shapes: the whole urlset, or the index of parts.
+      handler: async (request: UltimateRequest): Promise<Response> =>
+        applyCacheHeaders(
+          new Response((await answer(request)).sitemaps[0]?.xml ?? '', {
+            headers: { 'content-type': 'application/xml; charset=utf-8' },
+          }),
+          SEO_CACHE,
+        ),
+    },
+  ];
+}

package/src/serve-boot.ts

@@ -25,6 +25,7 @@ import { appRoutes } from './runtime-render';
 import { replicaOverrides } from './runtime-replica';
 import type { RunningServices } from './runtime-services';
 import { servedStorage, storageRoutes } from './runtime-storage';
+import { seoRoutes } from './seo-routes';
 import { loadDrainConfig } from './serve-drain';
 import { configureReporting, containerBinding, metricsPortFor, portFromEnv } from './serve-env';
 import type { ServedApp, ServeOptions } from './serve-types';
@@ -139,7 +140,7 @@ async function webSurface(
   const theme = themeBoot(await loadThemeMode(options.root));
   // The page's sync target and its scripts — the same call `x dev` makes, so the two cannot differ.
   // Before the service worker, which precaches those scripts.
-  const sync = await pageSync(options.root, options.env, buildId);
+  const sync = await pageSync(options.root, options.env, buildId, runtime.realtime);
   // The worker, from the SAME route table this process is about to serve — `describeRoutes()` is
   // the one projection `x.manifest.json`, `/_x`, the sitemap and `sw.js` are all built from, so a
   // route added here cannot be missing from the precache manifest.
@@ -173,12 +174,14 @@ async function webSurface(
     // The surface stylesheets the documents link. Built from the registry the `loadApp` above
     // filled, so this process serves exactly the CSS it renders against.
     ...styleRoutes(() => styleBundle()),
+    // `robots.txt` and `sitemap.xml`, the same two files the static export writes (`site-seo.ts`).
+    ...seoRoutes({ env: options.env }),
     // The page's one socket: its worker script, served beside the islands for their reason.
     ...sync.routes,
     ...appRoutes({
       buildId,
       resolveIsland: (file) => islands.resolverFor(file),
-      sync: sync.head,
+      ...(sync.head === undefined ? {} : { sync: sync.head }),
       persisted: sync.persisted,
       themeHead: theme.head,
       ...(pwa === undefined ? {} : { pwaHead: pwa.head + (serviceWorker?.head ?? '') }),

package/src/site-seo.ts

@@ -0,0 +1,78 @@
+// `robots.txt` and `sitemap.xml`, off the route table: ONE answer for the static export
+// (`apps/web/prerender.ts` writes it into the artifact) and the running web role (`seo-routes.ts`
+// serves it), so a crawler reads the same two files from a CDN and from a container.
+
+import type { Environment } from '@ultimat3/core';
+import type { RouteEntry } from '@ultimat3/render';
+import { routeEntries } from '@ultimat3/render';
+import { enumeratePrerender, fillPath } from '@ultimat3/render/server';
+import type { RouteRecord, SitemapFile } from '@ultimat3/seo';
+import { buildRobots, buildSitemap, isDynamic } from '@ultimat3/seo';
+import { readSiteMeta } from './seo-meta';
+
+export const ROBOTS_PATH = '/robots.txt';
+export const SITEMAP_PATH = '/sitemap.xml';
+
+export interface SiteSeoOptions {
+  /** The public origin every `<loc>` and the `Sitemap:` line are absolute against. */
+  readonly baseUrl: string;
+  /** Omitted: `ULTIMATE_ENV`, read by `@ultimat3/seo` — anything but `production` disallows. */
+  readonly environment?: Environment | undefined;
+  /**
+   * The concrete pages a build EMITTED for a dynamic route. The static export passes its report's,
+   * so the sitemap cannot name a page the artifact lacks; absent, `prerender()` is asked — which is
+   * the same list, enumerated by the same function the prerenderer calls.
+   */
+  readonly pagesFor?: ((routePath: string) => readonly string[]) | undefined;
+}
+
+export interface SiteSeo {
+  readonly robots: string;
+  /** Every sitemap file: `/sitemap.xml` alone, or the index at that path first and its parts after. */
+  readonly sitemaps: readonly SitemapFile[];
+}
+
+/** A `site/` page anyone may fetch. A policy on a `site/` route makes it not public, whatever the surface. */
+const isPublicSite = (entry: RouteEntry): boolean =>
+  entry.surface === 'site' && entry.config.policy === undefined;
+
+const pagesOf = async (entry: RouteEntry, options: SiteSeoOptions): Promise<readonly string[]> => {
+  if (options.pagesFor !== undefined) return options.pagesFor(entry.path);
+  const params = await enumeratePrerender(entry);
+  return params.map((set) => fillPath(entry.pattern.source, set));
+};
+
+/**
+ * The public `site/` routes as `@ultimat3/seo` reads them. `meta` is carried where it resolves
+ * without a request (`readSiteMeta`), which is what lets a page's own `robots: { index: false }`
+ * keep it out of the sitemap — a page that asks crawlers to stay away must not be listed for them.
+ */
+async function publicSiteRoutes(options: SiteSeoOptions): Promise<readonly RouteRecord[]> {
+  const metaByPath = new Map((await readSiteMeta()).records.map((r) => [r.path, r.meta]));
+  return routeEntries()
+    .filter(isPublicSite)
+    .map((entry) => {
+      const meta = metaByPath.get(entry.path);
+      return {
+        path: entry.path,
+        file: entry.file,
+        surface: 'site' as const,
+        render: entry.config.render,
+        ...(meta === undefined ? {} : { meta }),
+        ...(isDynamic(entry.path) ? { prerender: () => pagesOf(entry, options) } : {}),
+      };
+    });
+}
+
+export async function siteSeo(options: SiteSeoOptions): Promise<SiteSeo> {
+  const sitemap = await buildSitemap(await publicSiteRoutes(options), { baseUrl: options.baseUrl });
+  // Past 50,000 URLs `files` are `/sitemap-N.xml` and the index is `/sitemap.xml`; below it,
+  // `files` is that one file and there is no index.
+  const sitemaps = sitemap.index === undefined ? sitemap.files : [sitemap.index, ...sitemap.files];
+  const robots = buildRobots({
+    baseUrl: options.baseUrl,
+    sitemaps: [SITEMAP_PATH],
+    ...(options.environment === undefined ? {} : { environment: options.environment }),
+  });
+  return { robots, sitemaps };
+}

package/src/templates/scaffold-entries.ts

@@ -65,9 +65,7 @@ const prerender =
 // landed on disk — which is what \`x build --target static --json\` reads back.
 
 import { join } from 'node:path';
-import { DEFAULT_ORIGIN, type PrerenderReport, prerenderSite } from '@ultimat3/cli';
-import { routeEntries } from '@ultimat3/render';
-import { buildRobots, buildSitemap, type RouteRecord } from '@ultimat3/seo';
+import { DEFAULT_ORIGIN, type PrerenderReport, prerenderSite, siteSeo } from '@ultimat3/cli';
 
 const root = join(import.meta.dir, '..', '..');
 const flag = Bun.argv.indexOf('--out');
@@ -79,42 +77,28 @@ const out = (flag === -1 ? undefined : Bun.argv[flag + 1]) ?? join(root, '.x', '
 const origin = Bun.env.SITE_ORIGIN;
 
 /**
- * The route table as \`@ultimat3/seo\` reads it. \`RouteRecord\` is a static row and \`defineRoute\`
- * is a live declaration, so one has to be projected onto the other — and \`prerenderSite\` has
- * already loaded the app by the time this runs, which is what fills \`routeEntries()\`.
+ * \`sitemap.xml\` and \`robots.txt\`, into the same directory the HTML went: a static export is
+ * served with no process behind it, so the CDN needs the files. \`siteSeo\` is the same answer a
+ * running web role serves at \`/sitemap.xml\` and \`/robots.txt\` — the public \`site/\` routes, a
+ * page whose \`meta\` says \`robots: { index: false }\` left out — so a crawler reads one sitemap
+ * from the CDN and from the container.
  *
- * A DYNAMIC route contributes exactly the URLs this build enumerated for it, read back off the
- * report rather than by calling \`prerender()\` a second time: the sitemap then cannot name a page
- * the artifact does not contain, which is the only failure mode a sitemap really has.
- */
-const siteRoutes = (report: PrerenderReport): readonly RouteRecord[] =>
-  routeEntries()
-    .filter((entry) => entry.surface === 'site')
-    .map((entry) => ({
-      path: entry.path,
-      file: entry.file,
-      surface: 'site' as const,
-      render: entry.config.render,
-      prerender: () =>
-        report.pages.filter((page) => page.route === entry.path).map((page) => page.path),
-    }));
-
-/**
- * \`sitemap.xml\` and \`robots.txt\`, into the same directory the HTML went. Both belong to the
- * ARTIFACT rather than to a request: a static export is served with no process behind it, so a
- * route that answered them at run time would be a file the CDN never has.
+ * A DYNAMIC route contributes exactly the URLs this build emitted for it, read back off the report
+ * rather than by calling \`prerender()\` a second time: the sitemap then cannot name a page the
+ * artifact does not contain.
  *
- * \`buildRobots\` fails closed — anything that is not \`ULTIMATE_ENV=production\` emits
+ * \`robots.txt\` fails closed — anything that is not \`ULTIMATE_ENV=production\` emits
  * \`Disallow: /\` and advertises no sitemap — so a preview build cannot outrank the real site.
  */
 async function writeSeoFiles(report: PrerenderReport, baseUrl: string): Promise<readonly string[]> {
-  const sitemap = await buildSitemap(siteRoutes(report), { baseUrl });
-  // Past 50,000 URLs \`files\` are \`/sitemap-N.xml\` and the index is \`/sitemap.xml\`; below it,
-  // \`files\` is that one file and there is no index. Writing both lists covers each case once.
-  const written = sitemap.index === undefined ? sitemap.files : [sitemap.index, ...sitemap.files];
-  for (const file of written) await Bun.write(join(out, file.path), file.xml);
-  await Bun.write(join(out, 'robots.txt'), buildRobots({ baseUrl, sitemaps: ['/sitemap.xml'] }));
-  return [...written.map((file) => file.path), '/robots.txt'];
+  const seo = await siteSeo({
+    baseUrl,
+    pagesFor: (route) =>
+      report.pages.filter((page) => page.route === route).map((page) => page.path),
+  });
+  for (const file of seo.sitemaps) await Bun.write(join(out, file.path), file.xml);
+  await Bun.write(join(out, 'robots.txt'), seo.robots);
+  return [...seo.sitemaps.map((file) => file.path), '/robots.txt'];
 }
 
 if (import.meta.main) {