@sandboxsonny/ace-kit 0.11.0 → 0.12.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @sandboxsonny/ace-kit
 
+## 0.12.1
+
+### Patch Changes
+
+- ea4efe1: Fix the addresses in `sitemap.xml` and `robots.txt` on a site behind a proxy. They were built from the address the server was reached at, which behind a proxy such as Railway is the server's own internal address (`http://localhost:8080`). They now use the site's domain in the CMS (`ACE_SITE_DOMAIN`) over https, and fall back to the request's address only for a site on `localhost` or a `.test` domain. Also adds `client.siteDomain`.
+
+## 0.12.0
+
+### Minor Changes
+
+- 4d64734: Add a sitemap and `robots.txt`. `getSitemapResponse` and `getRobotsResponse` (Astro), and `sitemapLoader` and `robotsLoader` (React Router), each make the file in one line. The sitemap lists the site's live pages from the CMS, leaving out content types whose entries aren't pages of their own, with when each last changed. Also adds `client.getSitemap()`, and the pure `sitemapXml`, `robotsTxt` and `publicOrigin` helpers.
+
 ## 0.11.0
 
 ### Minor Changes

package/dist/astro.d.ts

@@ -53,6 +53,14 @@ type AceSite = {
   favicon: AceFavicon | null;
 };
 
+/** One page of the site as the CMS lists it for the sitemap. */
+type AceSitemapEntry = {
+  /** The address visitors use: "/" for the home entry, otherwise "/{content type}/{entry}". */
+  path: string;
+  /** When the entry was last changed, as an ISO date and time. */
+  updated_at: string;
+};
+
 /** A redirect the CMS has for an address, as its public API returns it. */
 type AceRedirect = {
   /** The old address the redirect is for. */
@@ -122,6 +130,13 @@ type AceValuesOf<Handle extends string> = Handle extends keyof AceContentTypes
   ? AceContentTypes[Handle]
   : Record<string, unknown>;
 
+type RobotsOptions = {
+    /** Asks every crawler to stay away, for a site that isn't live yet. */
+    disallowAll?: boolean;
+    /** The site's address, e.g. `https://example.com`. Left out, the address the request came to is used. */
+    origin?: string;
+};
+
 /** What to do with a request for a page: show an entry, redirect, or explain. */
 type AcePage<Values = Record<string, unknown>> =
   | { kind: "entry"; status: 200; entry: AceEntry<Values>; headers: Record<string, string> }
@@ -132,6 +147,7 @@ type AcePage<Values = Record<string, unknown>> =
 
 /** The client for this site, made from the integration's settings. Most pages only need the functions below. */
 declare const ace: {
+    siteDomain: string;
     getEntry<Handle extends AceContentTypeHandle>(contentTypeHandle: Handle, handle: string, options?: {
         previewToken?: string | null;
     }): Promise<AceEntry<AceValuesOf<Handle>> | null>;
@@ -140,6 +156,7 @@ declare const ace: {
     }): Promise<AceEntry<AceValuesOf<Handle>>[]>;
     getMenu(handle: string): Promise<AceMenu | null>;
     getRedirect(address: string): Promise<AceRedirect | null>;
+    getSitemap(): Promise<AceSitemapEntry[]>;
     getSite(): Promise<AceSite | null>;
     getContentTypes(): Promise<AceContentTypeSchema[]>;
 };
@@ -188,5 +205,31 @@ declare function getPage<Values = Record<string, unknown>>(astro: {
         headers: Headers;
     };
 }): Promise<AcePage<Values>>;
+/**
+ * The response for `/sitemap.xml`: the site's live pages (of the content types that have pages), with when each last
+ * changed. Make `src/pages/sitemap.xml.ts` with
+ *
+ *     import { getSitemapResponse } from "@sandboxsonny/ace-kit/astro";
+ *     export const GET = ({ url }) => getSitemapResponse({ url });
+ *
+ * The addresses are the site's domain (`ACE_SITE_DOMAIN`) over https, or the address of the request for a site on localhost; pass `{ origin: "https://example.com" }` to choose.
+ */
+declare const getSitemapResponse: (astro: {
+    url: URL;
+}, options?: {
+    origin?: string;
+}) => Promise<Response>;
+/**
+ * The response for `/robots.txt`, which lets crawlers in and points them at the sitemap. Make `src/pages/robots.txt.ts`
+ * with
+ *
+ *     import { getRobotsResponse } from "@sandboxsonny/ace-kit/astro";
+ *     export const GET = ({ url }) => getRobotsResponse({ url });
+ *
+ * Pass `{ disallowAll: true }` for a site that isn't live yet.
+ */
+declare const getRobotsResponse: (astro: {
+    url: URL;
+}, options?: RobotsOptions) => Response;
 
-export { ace, applyPage, getEntries, getEntry, getMenu, getMenuLinks, getPage, getSite };
+export { ace, applyPage, getEntries, getEntry, getMenu, getMenuLinks, getPage, getRobotsResponse, getSite, getSitemapResponse };

package/dist/astro.js

@@ -1,4 +1,4 @@
-import { createAceClient, loadMenuLinks, loadPage } from './chunk-PXT3H7C6.js';
+import { createAceClient, loadMenuLinks, loadPage, sitemapResponse, robotsResponse } from './chunk-RW4CVLES.js';
 import './chunk-M5WR5TCR.js';
 import './chunk-YLO6IAXF.js';
 import { ACE_SITE_DOMAIN, ACE_API_URL } from 'astro:env/server';
@@ -21,5 +21,7 @@ async function getPage(astro) {
   applyPage(astro.response, page);
   return page;
 }
+var getSitemapResponse = (astro, options = {}) => sitemapResponse(ace, astro.url, options);
+var getRobotsResponse = (astro, options = {}) => robotsResponse(astro.url, options, ace.siteDomain);
 
-export { ace, applyPage, getEntries, getEntry, getMenu, getMenuLinks, getPage, getSite };
+export { ace, applyPage, getEntries, getEntry, getMenu, getMenuLinks, getPage, getRobotsResponse, getSite, getSitemapResponse };

package/dist/{chunk-PXT3H7C6.js → chunk-RW4CVLES.js}

@@ -67,6 +67,8 @@ function createAceClient({
     return value;
   }
   return {
+    /** The domain of the site this client reads, as the CMS knows it. */
+    siteDomain,
     /**
      * One live entry of a content type, by its handle; null if the site has no such entry. With a preview token the
      * entry the token was made for comes back with its draft applied (never cached); a token that has run out throws
@@ -98,6 +100,10 @@ function createAceClient({
       const goesSomewhereSafe = redirect !== null && typeof redirect.to === "string" && (redirect.to.startsWith("/") && !redirect.to.startsWith("//") && !redirect.to.includes("\\") || /^https?:\/\/[^\s]+$/i.test(redirect.to)) && (redirect.status === 301 || redirect.status === 302);
       return goesSomewhereSafe ? redirect : null;
     },
+    /** The site's live pages for its sitemap, by path. Pages of content types that have no pages of their own are left out. */
+    async getSitemap() {
+      return await get("/public/sitemap") ?? [];
+    },
     /** The site itself: its name, and the social image its owners chose (null if none). */
     getSite() {
       return get("/public/site");
@@ -169,4 +175,58 @@ async function notFoundOrRedirect(client, url, previewToken, headers) {
   return { kind: "not-found", status: 404, headers };
 }
 
-export { AcePreviewExpiredError, AceUnavailableError, createAceClient, isCurrentPage, linksFromMenu, loadMenuLinks, loadPage };
+// src/helpers/sitemap.ts
+var escapeXml = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+var isLocalHost = (host) => host === "localhost" || /\.(localhost|test|local)$/.test(host) || /^[\d.]+$|:/.test(host);
+function publicOrigin(url, siteDomain) {
+  const domain = siteDomain?.trim().toLowerCase();
+  if (domain && !isLocalHost(domain)) return `https://${domain}`;
+  return isLocalHost(url.hostname) ? url.origin : `https://${url.host}`;
+}
+function sitemapXml(entries, origin) {
+  const base = origin.replace(/\/+$/, "");
+  const urls = entries.map((entry) => {
+    const lastChanged = Number.isNaN(Date.parse(entry.updated_at)) ? "" : new Date(entry.updated_at).toISOString();
+    return `  <url>
+    <loc>${escapeXml(`${base}${entry.path}`)}</loc>${lastChanged ? `
+    <lastmod>${lastChanged}</lastmod>` : ""}
+  </url>`;
+  }).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls}${urls ? "\n" : ""}</urlset>
+`;
+}
+function robotsTxt({ origin, disallowAll = false }) {
+  if (disallowAll) return "User-agent: *\nDisallow: /\n";
+  return `User-agent: *
+Allow: /
+
+Sitemap: ${origin.replace(/\/+$/, "")}/sitemap.xml
+`;
+}
+async function sitemapResponse(client, url, options = {}) {
+  try {
+    const entries = await client.getSitemap();
+    return new Response(sitemapXml(entries, options.origin ?? publicOrigin(url, client.siteDomain)), {
+      headers: { "Content-Type": "application/xml; charset=utf-8", "Cache-Control": "public, max-age=300" }
+    });
+  } catch (error) {
+    if (!(error instanceof AceUnavailableError)) throw error;
+    console.error(error.message);
+    return new Response("The sitemap is unavailable right now.", {
+      status: 503,
+      headers: { "Content-Type": "text/plain; charset=utf-8", "Retry-After": "300" }
+    });
+  }
+}
+function robotsResponse(url, options = {}, siteDomain) {
+  return new Response(
+    robotsTxt({ origin: options.origin ?? publicOrigin(url, siteDomain), disallowAll: options.disallowAll }),
+    {
+      headers: { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "public, max-age=3600" }
+    }
+  );
+}
+
+export { AcePreviewExpiredError, AceUnavailableError, createAceClient, isCurrentPage, linksFromMenu, loadMenuLinks, loadPage, publicOrigin, robotsResponse, robotsTxt, sitemapResponse, sitemapXml };

package/dist/cli.js

@@ -9,8 +9,8 @@ if (major < 22 || major === 22 && minor < 12) {
   process.exit(1);
 }
 try {
-  const { createRealEnvironment } = await import("./environment-LTPUSFAK.js");
-  const { runCli } = await import("./main-IKZ3DQLC.js");
+  const { createRealEnvironment } = await import("./environment-CXO6CVNR.js");
+  const { runCli } = await import("./main-4TEJQB6N.js");
   const environment = await createRealEnvironment();
   process.exit(await runCli(process.argv.slice(2), environment));
 } catch (error) {

package/dist/{environment-LTPUSFAK.js → environment-CXO6CVNR.js}

@@ -145,7 +145,7 @@ function createLastApiUrl(path) {
 }
 
 // src/cli/version.ts
-var aceKitVersion = true ? "0.11.0" : "development";
+var aceKitVersion = true ? "0.12.1" : "development";
 
 // src/cli/environment.ts
 var runCommand = (command, commandArguments, input) => new Promise((resolve, reject) => {

package/dist/index.d.ts

@@ -133,12 +133,22 @@ type AceSite = {
   favicon: AceFavicon | null;
 };
 
+/** One page of the site as the CMS lists it for the sitemap. */
+type AceSitemapEntry = {
+  /** The address visitors use: "/" for the home entry, otherwise "/{content type}/{entry}". */
+  path: string;
+  /** When the entry was last changed, as an ISO date and time. */
+  updated_at: string;
+};
+
 /**
  * A client for the CMS Ace public API. It runs on the server only, so the visitor's browser never talks to the
  * API. The API finds the site from X-Ace-Site-Domain, which this client sets to the site's domain. X-Forwarded-Host
  * is sent too, for an API that predates the first (some platforms' proxies rewrite X-Forwarded-Host on the way in).
  */
 declare function createAceClient({ apiUrl, siteDomain, cacheSeconds, fetchImplementation, now, }: AceClientOptions): {
+    /** The domain of the site this client reads, as the CMS knows it. */
+    siteDomain: string;
     /**
      * One live entry of a content type, by its handle; null if the site has no such entry. With a preview token the
      * entry the token was made for comes back with its draft applied (never cached); a token that has run out throws
@@ -158,6 +168,8 @@ declare function createAceClient({ apiUrl, siteDomain, cacheSeconds, fetchImplem
      * `address` is the path with its query string, e.g. "/old-page?id=7".
      */
     getRedirect(address: string): Promise<AceRedirect | null>;
+    /** The site's live pages for its sitemap, by path. Pages of content types that have no pages of their own are left out. */
+    getSitemap(): Promise<AceSitemapEntry[]>;
     /** The site itself: its name, and the social image its owners chose (null if none). */
     getSite(): Promise<AceSite | null>;
     /** What the site's content types and fields are, which is what type generation reads. */
@@ -551,6 +563,36 @@ type AceSeoProperties = {
  */
 declare function seoProperties(options: AceSeoOptions): AceSeoProperties;
 
+/**
+ * The address the site's pages are at, for the full addresses in a sitemap. It is the site's domain in the CMS
+ * (`ACE_SITE_DOMAIN`) over https, because behind a proxy the server only sees its own internal address
+ * (`localhost:8080` on Railway), so the request can't say. For a site on `localhost` (or a `.test` domain), which
+ * has no public address, it is the address the request came to. Pass `origin` to the response helpers to choose it.
+ */
+declare function publicOrigin(url: URL, siteDomain?: string): string;
+/** The sitemap file for a site: one `<url>` per page, with when it last changed. `origin` is e.g. `https://example.com`. */
+declare function sitemapXml(entries: AceSitemapEntry[], origin: string): string;
+type RobotsOptions = {
+    /** Asks every crawler to stay away, for a site that isn't live yet. */
+    disallowAll?: boolean;
+    /** The site's address, e.g. `https://example.com`. Left out, the address the request came to is used. */
+    origin?: string;
+};
+/** The `robots.txt` for a site: everything may be crawled, and the sitemap is pointed at. */
+declare function robotsTxt({ origin, disallowAll }: {
+    origin: string;
+    disallowAll?: boolean;
+}): string;
+/**
+ * The response for `/sitemap.xml`: the site's live pages from the CMS. If the CMS can't be reached it answers 503, so a
+ * crawler tries again later instead of reading an empty sitemap.
+ */
+declare function sitemapResponse(client: AceClient, url: URL, options?: {
+    origin?: string;
+}): Promise<Response>;
+/** The response for `/robots.txt`. */
+declare function robotsResponse(url: URL, options?: RobotsOptions, siteDomain?: string): Response;
+
 /**
  * A text area field's text as HTML. With `multiline` (the default) blank lines start new paragraphs (`<p>`) and a
  * single new line is a line break; without it the text is one line, with no element around it. Every piece of text
@@ -592,4 +634,4 @@ type AceSection = {
   blocks: AceSectionBlock[];
 };
 
-export { type AceAddress, type AceClient, type AceClientOptions, type AceContentTypeHandle, type AceContentTypeSchema, type AceContentTypes, type AceDateFormat, type AceEntry, type AceFavicon, type AceFieldSchema, type AceImageAttributes, type AceImageData, type AceImageOptions, type AceLinkAttributes, type AceLinkData, type AceMenu, type AceMenuItem, type AceNavigationLink, type AcePage, AcePreviewExpiredError, type AceRedirect, type AceRichTextDocument, type AceRichTextMark, type AceRichTextNode, type AceSection, type AceSectionBlock, type AceSeoOptions, type AceSeoProperties, type AceSite, AceUnavailableError, type AceValuesOf, type BlockDefinition, type SectionDefinition, type SectionFieldDefinition, type SectionFieldType, type SectionOf, type SectionTypesPayload, type ValuesOfFields, addFramingPolicy, addressFromPath, checkSectionDefinition, createAceClient, defineSection, formatAceDate, framingPolicy, headingLevel, homeAddress, imageAttributes, isCurrentPage, isHomeAddress, isInternalPath, isRefreshRequest, linkAddress, linkAttributes, linksFromMenu, listStart, listenForPreviewRefresh, loadMenuLinks, loadPage, originOf, pageNotices, pathOfAddress, previewHeaders, previewParameter, previewTokenFrom, refreshMessageType, refreshPageContent, renderRichText, renderTextArea, richTextImageSizes, sectionTypesPayload, seoDescriptionHandle, seoProperties, seoTitleHandle, swapPageContent, visitablePath };
+export { type AceAddress, type AceClient, type AceClientOptions, type AceContentTypeHandle, type AceContentTypeSchema, type AceContentTypes, type AceDateFormat, type AceEntry, type AceFavicon, type AceFieldSchema, type AceImageAttributes, type AceImageData, type AceImageOptions, type AceLinkAttributes, type AceLinkData, type AceMenu, type AceMenuItem, type AceNavigationLink, type AcePage, AcePreviewExpiredError, type AceRedirect, type AceRichTextDocument, type AceRichTextMark, type AceRichTextNode, type AceSection, type AceSectionBlock, type AceSeoOptions, type AceSeoProperties, type AceSite, type AceSitemapEntry, AceUnavailableError, type AceValuesOf, type BlockDefinition, type RobotsOptions, type SectionDefinition, type SectionFieldDefinition, type SectionFieldType, type SectionOf, type SectionTypesPayload, type ValuesOfFields, addFramingPolicy, addressFromPath, checkSectionDefinition, createAceClient, defineSection, formatAceDate, framingPolicy, headingLevel, homeAddress, imageAttributes, isCurrentPage, isHomeAddress, isInternalPath, isRefreshRequest, linkAddress, linkAttributes, linksFromMenu, listStart, listenForPreviewRefresh, loadMenuLinks, loadPage, originOf, pageNotices, pathOfAddress, previewHeaders, previewParameter, previewTokenFrom, publicOrigin, refreshMessageType, refreshPageContent, renderRichText, renderTextArea, richTextImageSizes, robotsResponse, robotsTxt, sectionTypesPayload, seoDescriptionHandle, seoProperties, seoTitleHandle, sitemapResponse, sitemapXml, swapPageContent, visitablePath };

package/dist/index.js

@@ -1,7 +1,7 @@
 export { pageNotices } from './chunk-XPZY5R5A.js';
 export { headingLevel, imageAttributes, isInternalPath, linkAddress, linkAttributes, listStart, renderRichText, renderTextArea, richTextImageSizes } from './chunk-FVR55GIU.js';
 export { listenForPreviewRefresh, refreshPageContent } from './chunk-YN7LJWGI.js';
-export { AcePreviewExpiredError, AceUnavailableError, createAceClient, isCurrentPage, linksFromMenu, loadMenuLinks, loadPage } from './chunk-PXT3H7C6.js';
+export { AcePreviewExpiredError, AceUnavailableError, createAceClient, isCurrentPage, linksFromMenu, loadMenuLinks, loadPage, publicOrigin, robotsResponse, robotsTxt, sitemapResponse, sitemapXml } from './chunk-RW4CVLES.js';
 export { addressFromPath, homeAddress, isHomeAddress, pathOfAddress, visitablePath } from './chunk-M5WR5TCR.js';
 export { addFramingPolicy, framingPolicy, isRefreshRequest, originOf, previewHeaders, previewParameter, previewTokenFrom, refreshMessageType, swapPageContent } from './chunk-YLO6IAXF.js';
 

package/dist/{main-IKZ3DQLC.js → main-4TEJQB6N.js}

@@ -1345,6 +1345,8 @@ function createAceClient({
     return value;
   }
   return {
+    /** The domain of the site this client reads, as the CMS knows it. */
+    siteDomain,
     /**
      * One live entry of a content type, by its handle; null if the site has no such entry. With a preview token the
      * entry the token was made for comes back with its draft applied (never cached); a token that has run out throws
@@ -1376,6 +1378,10 @@ function createAceClient({
       const goesSomewhereSafe = redirect !== null && typeof redirect.to === "string" && (redirect.to.startsWith("/") && !redirect.to.startsWith("//") && !redirect.to.includes("\\") || /^https?:\/\/[^\s]+$/i.test(redirect.to)) && (redirect.status === 301 || redirect.status === 302);
       return goesSomewhereSafe ? redirect : null;
     },
+    /** The site's live pages for its sitemap, by path. Pages of content types that have no pages of their own are left out. */
+    async getSitemap() {
+      return await get("/public/sitemap") ?? [];
+    },
     /** The site itself: its name, and the social image its owners chose (null if none). */
     getSite() {
       return get("/public/site");

package/dist/react-router-server.d.ts

@@ -136,12 +136,22 @@ type AceRedirect = {
   status: 301 | 302;
 };
 
+/** One page of the site as the CMS lists it for the sitemap. */
+type AceSitemapEntry = {
+  /** The address visitors use: "/" for the home entry, otherwise "/{content type}/{entry}". */
+  path: string;
+  /** When the entry was last changed, as an ISO date and time. */
+  updated_at: string;
+};
+
 /**
  * A client for the CMS Ace public API. It runs on the server only, so the visitor's browser never talks to the
  * API. The API finds the site from X-Ace-Site-Domain, which this client sets to the site's domain. X-Forwarded-Host
  * is sent too, for an API that predates the first (some platforms' proxies rewrite X-Forwarded-Host on the way in).
  */
 declare function createAceClient({ apiUrl, siteDomain, cacheSeconds, fetchImplementation, now, }: AceClientOptions): {
+    /** The domain of the site this client reads, as the CMS knows it. */
+    siteDomain: string;
     /**
      * One live entry of a content type, by its handle; null if the site has no such entry. With a preview token the
      * entry the token was made for comes back with its draft applied (never cached); a token that has run out throws
@@ -161,6 +171,8 @@ declare function createAceClient({ apiUrl, siteDomain, cacheSeconds, fetchImplem
      * `address` is the path with its query string, e.g. "/old-page?id=7".
      */
     getRedirect(address: string): Promise<AceRedirect | null>;
+    /** The site's live pages for its sitemap, by path. Pages of content types that have no pages of their own are left out. */
+    getSitemap(): Promise<AceSitemapEntry[]>;
     /** The site itself: its name, and the social image its owners chose (null if none). */
     getSite(): Promise<AceSite | null>;
     /** What the site's content types and fields are, which is what type generation reads. */
@@ -169,6 +181,13 @@ declare function createAceClient({ apiUrl, siteDomain, cacheSeconds, fetchImplem
 /** The client `createAceClient` returns. */
 type AceClient = ReturnType<typeof createAceClient>;
 
+type RobotsOptions = {
+    /** Asks every crawler to stay away, for a site that isn't live yet. */
+    disallowAll?: boolean;
+    /** The site's address, e.g. `https://example.com`. Left out, the address the request came to is used. */
+    origin?: string;
+};
+
 /** What the root loader (`createRootLoader`) puts in the root route's data, for `useAceMenu` and `useAcePreview`. */
 type AceRootData = {
   ace: {
@@ -229,6 +248,31 @@ declare function createPageLoader<Values = Record<string, unknown>>(): ({ reques
     entry: AceEntry<Values>;
     headers: Record<string, string>;
 }>>;
+/**
+ * The loader for `/sitemap.xml`: the site's live pages (of the content types that have pages), with when each last
+ * changed. Add a route `route("sitemap.xml", "routes/sitemap.tsx")` (before the catch-all) whose file is
+ *
+ *     export { sitemapLoader as loader } from "@sandboxsonny/ace-kit/react-router/server";
+ *
+ * It uses the site's domain (`ACE_SITE_DOMAIN`) over https, or the address of the request for a site on localhost; for another address use `createSitemapLoader({ origin })`.
+ */
+declare const createSitemapLoader: (options?: {
+    origin?: string;
+}) => ({ request }: {
+    request: Request;
+}) => Promise<Response>;
+/** `createSitemapLoader()` with the defaults. */
+declare const sitemapLoader: ({ request }: {
+    request: Request;
+}) => Promise<Response>;
+/** The loader for `/robots.txt`, which lets crawlers in and points them at the sitemap. See `createSitemapLoader`. */
+declare const createRobotsLoader: (options?: RobotsOptions) => ({ request }: {
+    request: Request;
+}) => Response;
+/** `createRobotsLoader()` with the defaults. */
+declare const robotsLoader: ({ request }: {
+    request: Request;
+}) => Response;
 /** `createPageLoader()` for a site that has not generated types for its content. */
 declare const loader: ({ request }: {
     request: Request;
@@ -281,4 +325,4 @@ declare const streamTimeout = 5000;
  */
 declare function handleRequest(request: Request, responseStatusCode: number, responseHeaders: Headers, routerContext: EntryContext, _loadContext: AppLoadContext): Promise<Response>;
 
-export { createPageLoader, createRootLoader, getAceClient, getEntries, getEntry, getMenu, getMenuLinks, getSite, handleRequest, headers, loader, streamTimeout };
+export { createPageLoader, createRobotsLoader, createRootLoader, createSitemapLoader, getAceClient, getEntries, getEntry, getMenu, getMenuLinks, getSite, handleRequest, headers, loader, robotsLoader, sitemapLoader, streamTimeout };

package/dist/react-router-server.js

@@ -1,4 +1,4 @@
-import { createAceClient, loadMenuLinks, loadPage } from './chunk-PXT3H7C6.js';
+import { createAceClient, loadMenuLinks, loadPage, sitemapResponse, robotsResponse } from './chunk-RW4CVLES.js';
 import './chunk-M5WR5TCR.js';
 import { hostedAdminOrigin, hostedApiUrl } from './chunk-N5DIMG3X.js';
 import { previewTokenFrom, addFramingPolicy } from './chunk-YLO6IAXF.js';
@@ -43,6 +43,14 @@ function createPageLoader() {
     return data(page, { status: page.status, headers: page.headers });
   };
 }
+var createSitemapLoader = (options = {}) => function loader2({ request }) {
+  return sitemapResponse(getAceClient(), new URL(request.url), options);
+};
+var sitemapLoader = createSitemapLoader();
+var createRobotsLoader = (options = {}) => function loader2({ request }) {
+  return robotsResponse(new URL(request.url), options, getAceClient().siteDomain);
+};
+var robotsLoader = createRobotsLoader();
 var loader = createPageLoader();
 var headers = ({ loaderHeaders }) => loaderHeaders;
 function createRootLoader({ menu, fallback = [] }) {
@@ -88,4 +96,4 @@ function handleRequest(request, responseStatusCode, responseHeaders, routerConte
   });
 }
 
-export { createPageLoader, createRootLoader, getAceClient, getEntries, getEntry, getMenu, getMenuLinks, getSite, handleRequest, headers, loader, streamTimeout };
+export { createPageLoader, createRobotsLoader, createRootLoader, createSitemapLoader, getAceClient, getEntries, getEntry, getMenu, getMenuLinks, getSite, handleRequest, headers, loader, robotsLoader, sitemapLoader, streamTimeout };

package/docs/api-reference.md

@@ -86,13 +86,14 @@ Types: `AceSection`, `AceSectionBlock`, `SectionDefinition`, `SectionFieldDefini
 
 `@sandboxsonny/ace-kit/astro` (uses the integration's settings, so there is no client to create):
 
-|                                                                                           |                                                                                                                                                           |
-| ----------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `getPage(Astro)`                                                                          | What to show for the page being requested; also sets the response's status and headers. A `redirect` is returned for you to act on with `Astro.redirect`. |
-| `getEntry(contentType, handle)`, `getEntries(contentType, { limit? })`, `getMenu(handle)` | As on the client.                                                                                                                                         |
-| `getMenuLinks(handle, { fallback? })`                                                     | A menu's links, or the fallback if the menu is missing or the CMS is down.                                                                                |
-| `applyPage(response, page)`                                                               | Puts a page's status and headers on a response.                                                                                                           |
-| `ace`                                                                                     | The client these use.                                                                                                                                     |
+|                                                                                                     |                                                                                                                                                           |
+| --------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `getPage(Astro)`                                                                                    | What to show for the page being requested; also sets the response's status and headers. A `redirect` is returned for you to act on with `Astro.redirect`. |
+| `getEntry(contentType, handle)`, `getEntries(contentType, { limit? })`, `getMenu(handle)`           | As on the client.                                                                                                                                         |
+| `getSitemapResponse({ url }, { origin? })`, `getRobotsResponse({ url }, { origin?, disallowAll? })` | The responses for `/sitemap.xml` and `/robots.txt` (see [Astro](./astro.md)).                                                                             |
+| `getMenuLinks(handle, { fallback? })`                                                               | A menu's links, or the fallback if the menu is missing or the CMS is down.                                                                                |
+| `applyPage(response, page)`                                                                         | Puts a page's status and headers on a response.                                                                                                           |
+| `ace`                                                                                               | The client these use.                                                                                                                                     |
 
 Components, by file: `AceImage.astro`, `AceLink.astro`, `AceSections.astro`, `AceRichText.astro`, `AceTextArea.astro`, `AceMenu.astro`, `AceNotice.astro`, `AcePreviewRefresh.astro`.
 
@@ -110,13 +111,14 @@ Components, by file: `AceImage.astro`, `AceLink.astro`, `AceSections.astro`, `Ac
 
 `@sandboxsonny/ace-kit/react-router/server` (server only):
 
-|                                                                     |                                                                  |
-| ------------------------------------------------------------------- | ---------------------------------------------------------------- |
-| `createPageLoader<Values>()`, `loader`                              | The loader for the catch-all route that draws every page.        |
-| `headers`                                                           | The route's `headers` export.                                    |
-| `createRootLoader({ menu, fallback? })`                             | The root loader: the menu's links and whether this is a preview. |
-| `handleRequest`, `streamTimeout`                                    | The server entry.                                                |
-| `getEntry`, `getEntries`, `getMenu`, `getMenuLinks`, `getAceClient` | Read content from your own loaders.                              |
+|                                                                                                |                                                                                           |
+| ---------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `createPageLoader<Values>()`, `loader`                                                         | The loader for the catch-all route that draws every page.                                 |
+| `headers`                                                                                      | The route's `headers` export.                                                             |
+| `createRootLoader({ menu, fallback? })`                                                        | The root loader: the menu's links and whether this is a preview.                          |
+| `handleRequest`, `streamTimeout`                                                               | The server entry.                                                                         |
+| `sitemapLoader`, `robotsLoader`, `createSitemapLoader(options)`, `createRobotsLoader(options)` | The loaders for `/sitemap.xml` and `/robots.txt` (see [React Router](./react-router.md)). |
+| `getEntry`, `getEntries`, `getMenu`, `getMenuLinks`, `getAceClient`                            | Read content from your own loaders.                                                       |
 
 ## React (`@sandboxsonny/ace-kit/react`)
 

package/docs/astro.md

@@ -48,6 +48,24 @@ if (page.kind === "redirect") return Astro.redirect(page.location, page.status);
 
 Addresses are `/{content type}/{entry}` as on Shopify, `/` is the `home` entry of `pages`, and `/pages/home` redirects to `/`. An address with no page is redirected too if the site's owners set up a redirect for it in the CMS (Redirects), so old addresses from a site you moved keep working. `page.kind` is `entry`, `redirect`, `not-found`, `unavailable` or `preview-expired`. `AceNotice` draws a heading and a message for the last three; draw your own if you prefer.
 
+## Sitemap and robots.txt
+
+Search engines find a site's pages through `/sitemap.xml` and are pointed at it by `/robots.txt`. Both are one small file each; the sitemap lists the live pages from the CMS (only the content types that have "Entries have their own pages" ticked), with when each last changed.
+
+```ts
+// src/pages/sitemap.xml.ts
+import { getSitemapResponse } from "@sandboxsonny/ace-kit/astro";
+export const GET = ({ url }) => getSitemapResponse({ url });
+```
+
+```ts
+// src/pages/robots.txt.ts
+import { getRobotsResponse } from "@sandboxsonny/ace-kit/astro";
+export const GET = ({ url }) => getRobotsResponse({ url });
+```
+
+Addresses in the sitemap are your site's domain (`ACE_SITE_DOMAIN`) over `https`, or the address of the request when the site is on `localhost`; pass `{ origin: "https://www.example.com" }` to either to choose. `getRobotsResponse({ url }, { disallowAll: true })` asks crawlers to stay away, for a site that isn't live yet. Delete any `robots.txt` in `public/`, which would take its place.
+
 ## Reading content
 
 Anywhere in a page or component:

package/docs/react-router.md

@@ -102,6 +102,22 @@ From `@sandboxsonny/ace-kit/react-router` (these are safe in the browser):
 - **AceImage** is an `<img>` with `src`, `srcset`, `sizes`, size and alt text. Set `sizes` to how wide it is shown, and `lazy={false}` for the image at the top of the page.
 - **AceNotice** is the heading and message for a page that isn't an entry. Give it a `className`.
 
+## Sitemap and robots.txt
+
+Search engines find a site's pages through `/sitemap.xml` and are pointed at it by `/robots.txt`. Add two routes before the catch-all in `app/routes.ts`: `route("sitemap.xml", "routes/sitemap.tsx")` and `route("robots.txt", "routes/robots.tsx")`, whose files are one line each:
+
+```ts
+// app/routes/sitemap.tsx
+export { sitemapLoader as loader } from "@sandboxsonny/ace-kit/react-router/server";
+```
+
+```ts
+// app/routes/robots.tsx
+export { robotsLoader as loader } from "@sandboxsonny/ace-kit/react-router/server";
+```
+
+The sitemap lists the live pages from the CMS (only the content types that have "Entries have their own pages" ticked), with when each last changed. Addresses are your site's domain (`ACE_SITE_DOMAIN`) over `https`, or the address of the request when the site is on `localhost`. For another address, or to keep crawlers away from a site that isn't live yet, use `createSitemapLoader({ origin })` and `createRobotsLoader({ origin, disallowAll })`.
+
 ## Reading content in your own loaders
 
 From `@sandboxsonny/ace-kit/react-router/server`, with no client to create:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sandboxsonny/ace-kit",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "Everything a website needs to use CMS Ace: a typed client, addressing, images, menus, rich text, live preview, and Astro and React adapters.",
   "keywords": [
     "cms",