@iterant/site-runtime 3.0.2

package/src/lib/content-values.ts

@@ -0,0 +1,201 @@
+import { z } from "astro/zod";
+
+// The content-value grammar: every piece of VISIBLE COPY in a brand site —
+// headings, paragraphs, link labels, image alt text — lives in page/chrome
+// JSON entries as a tagged wrapper, never as a literal string in TSX/JSX.
+// The wrappers are what make copy machine-addressable: the visual editor
+// binds to a wrapper by path, and translation rewrites exactly the wrapped
+// copy fields (text.value, link.text, image.alt) while never touching
+// hrefs, srcs, ids, or config values.
+//
+//   { "type": "text",  "value": "Visible prose" }
+//   { "type": "link",  "text": "Start free", "href": "/signup" }
+//   { "type": "image", "src": "/images/x.webp", "alt": "Description" }
+//   { "type": "svg",   "markup": "<svg…>", "label": "Accessible name" }
+//   { "type": "color", "value": "#0ea5e9" }
+//   { "type": "array", "items": [ { …wrapped fields per item… } ] }
+//
+// Non-copy config values stay bare: numbers, booleans, and short lowercase
+// tokens (icon names, variants — "zap", "center", "inverse"). A bare string
+// containing uppercase letters or spaces is rejected by the schema: that is
+// the guard that keeps prose out of unwrapped strings.
+
+export interface TextContent {
+  type: "text";
+  value: string;
+}
+
+export interface LinkContent {
+  type: "link";
+  text: string;
+  href: string;
+  target?: "_blank" | "_self";
+}
+
+/** A responsive-image candidate: a source URL paired with a width ("400w")
+ *  or pixel-density ("2x") descriptor. */
+export interface ImageCandidate {
+  src: string;
+  assetId?: string;
+  descriptor: string;
+}
+
+export interface ImageContent {
+  type: "image";
+  src: string;
+  alt: string;
+  assetId?: string;
+  /** Optional responsive candidates. The renderer composes the `srcset`
+   *  attribute from these; `src` stays the always-valid fallback. */
+  srcset?: ImageCandidate[];
+}
+
+export interface SvgContent {
+  type: "svg";
+  markup: string;
+  label?: string;
+}
+
+export interface ColorContent {
+  type: "color";
+  value: string;
+}
+
+export interface ArrayContent {
+  type: "array";
+  items: ContentItem[];
+}
+
+export type ContentValue =
+  | TextContent
+  | LinkContent
+  | ImageContent
+  | SvgContent
+  | ColorContent
+  | ArrayContent;
+
+/** Bare non-copy values: numbers, booleans, short lowercase config tokens. */
+export type ConfigValue = string | number | boolean;
+
+export type ContentLeaf = ContentValue | ConfigValue;
+export type ContentItem = Record<string, ContentLeaf>;
+export type ContentProps = Record<string, ContentLeaf>;
+
+export const textContentSchema = z
+  .object({
+    type: z.literal("text"),
+    // A lone URL/path in a text wrapper is a modeling error: translation
+    // would try to rewrite it and the editor would offer a text input for
+    // a destination. Links live in link wrappers ({type:"link",text,href});
+    // image sources in image wrappers.
+    value: z
+      .string()
+      .refine(
+        (value) => !/^(?:\/|#|https?:\/\/)\S*$/.test(value.trim()),
+        'this looks like a URL or path — use {"type":"link","text":…,"href":…} (or image src), not a text wrapper',
+      ),
+  })
+  .strict();
+
+export const linkContentSchema = z
+  .object({
+    type: z.literal("link"),
+    text: z.string(),
+    href: z.string(),
+    target: z.enum(["_blank", "_self"]).optional(),
+  })
+  .strict();
+
+// A srcset candidate descriptor is a width ("400w") or pixel density ("2x").
+const descriptorSchema = z
+  .string()
+  .regex(
+    /^(?:[1-9]\d*w|\d+(?:\.\d+)?x)$/,
+    'srcset descriptor must be a width ("400w") or density ("2x")',
+  );
+
+export const imageCandidateSchema = z
+  .object({
+    src: z.string(),
+    assetId: z.string().optional(),
+    descriptor: descriptorSchema,
+  })
+  .strict();
+
+export const imageContentSchema = z
+  .object({
+    type: z.literal("image"),
+    src: z.string(),
+    alt: z.string(),
+    assetId: z.string().optional(),
+    // Responsive candidates (optional): the renderer composes `srcset` from
+    // these; `src` remains the fallback. Absent for a single-resolution image.
+    srcset: z.array(imageCandidateSchema).optional(),
+  })
+  .strict();
+
+export const svgContentSchema = z
+  .object({
+    type: z.literal("svg"),
+    markup: z.string(),
+    label: z.string().optional(),
+  })
+  .strict();
+
+export const colorContentSchema = z
+  .object({ type: z.literal("color"), value: z.string() })
+  .strict();
+
+export const configTokenSchema = z
+  .string()
+  .max(48)
+  .regex(
+    /^[a-z0-9][a-z0-9_./-]*$/,
+    'bare strings are for short config tokens only ("zap", "center", "3xl"); visible copy must be wrapped: {"type":"text","value":"…"}',
+  );
+
+const configValueSchema = z.union([z.number(), z.boolean(), configTokenSchema]);
+
+// Prop keys become edit/translation paths (props.features.0.title), so they
+// must be path-safe: alphanumeric camelCase, no dots or brackets.
+const propKeySchema = z
+  .string()
+  .regex(
+    /^[a-zA-Z][a-zA-Z0-9]*$/,
+    "prop keys are alphanumeric camelCase (they become edit and translation paths)",
+  );
+
+export const contentLeafSchema: z.ZodType<ContentLeaf> = z.lazy(() =>
+  z.union([
+    textContentSchema,
+    linkContentSchema,
+    imageContentSchema,
+    svgContentSchema,
+    colorContentSchema,
+    arrayContentSchema,
+    configValueSchema,
+  ]),
+);
+
+export const contentItemSchema: z.ZodType<ContentItem> = z.record(
+  propKeySchema,
+  contentLeafSchema,
+);
+
+export const arrayContentSchema = z
+  .object({ type: z.literal("array"), items: z.array(contentItemSchema) })
+  .strict();
+
+export const contentPropsSchema: z.ZodType<ContentProps> = z.record(
+  propKeySchema,
+  contentLeafSchema,
+);
+
+/** Typed `{type:"array"}` schema for registered sections with a known item shape. */
+export const arrayOf = <T extends z.ZodRawShape>(shape: T) =>
+  z
+    .object({
+      type: z.literal("array"),
+      items: z.array(z.object(shape).strict()),
+    })
+    .strict();

package/src/lib/hreflang.ts

@@ -0,0 +1,123 @@
+import { DEFAULT_LOCALE, normalizeBcp47, parseEntryId } from "./locales";
+
+// hreflang alternates for locale sibling pages (starter 2.9.0). A page with
+// locale siblings advertises one `<link rel="alternate" hreflang>` per
+// NON-DRAFT sibling in the group, plus exactly one `x-default` pointing at the
+// unsuffixed base entry. A page with no siblings emits nothing. Ported from the
+// legacy `derive_hreflang_set` (backend translation_group.py): published/
+// indexable rows only (starter: non-draft), one x-default = the default-locale
+// row, deduped on a normalized locale key, hreflang values in canonical BCP-47.
+
+/** One reciprocal hreflang alternate. `hreflang` is BCP-47 or "x-default". */
+export interface HreflangAlternate {
+  hreflang: string;
+  href: string;
+}
+
+/** The minimal page-entry shape the derivation reads. */
+export interface HreflangEntry {
+  /** Collection entry id (`example`, `example.es`). */
+  id: string;
+  /** The entry's `route` field (`/example`, `/es/example`). */
+  route: string;
+  draft: boolean;
+}
+
+/** A `pages` collection entry, as `pageLocaleHead` consumes it. */
+export interface PagesCollectionEntry {
+  id: string;
+  data: { route: string; draft: boolean };
+}
+
+/**
+ * The `<html lang>` value for a page, from its entry id: base entries are the
+ * brand default (`en`); siblings carry their locale in canonical BCP-47
+ * casing (`example.pt-br` → `pt-BR`).
+ */
+export function pageLang(entryId: string): string {
+  const { locale } = parseEntryId(entryId);
+  return locale ? normalizeBcp47(locale) : DEFAULT_LOCALE;
+}
+
+/**
+ * The locale head pair every page emits (starter 2.10.0): `<html lang>` plus
+ * the reciprocal hreflang alternates, from an entry id and the full `pages`
+ * collection. The one-liner bespoke shells use for head parity with the
+ * catch-all — base bespoke pages advertise their locale siblings through the
+ * same derivation, so siblings need no per-page head work.
+ */
+export function pageLocaleHead(params: {
+  entries: PagesCollectionEntry[];
+  entryId: string;
+  site: URL | string | undefined;
+}): { lang: string; hreflang: HreflangAlternate[] } {
+  return {
+    lang: pageLang(params.entryId),
+    hreflang: deriveHreflangAlternates({
+      entries: params.entries.map((entry) => ({
+        id: entry.id,
+        route: entry.data.route,
+        draft: entry.data.draft,
+      })),
+      baseName: parseEntryId(params.entryId).base,
+      site: params.site,
+    }),
+  };
+}
+
+function absolute(route: string, site: URL | string | undefined): string {
+  if (!site) return route; // dev without a configured `site` — relative href
+  return new URL(route, site.toString()).toString();
+}
+
+/**
+ * The reciprocal hreflang set for the group `baseName` belongs to, derived from
+ * ALL page entries (the caller passes the whole collection). Every non-draft
+ * entry in the group contributes one alternate; the base entry also seeds the
+ * single `x-default`. Draft siblings are never advertised (unpublished
+ * translations must not leak to crawlers). Deduped on the normalized locale key
+ * (first entry wins); hrefs absolute via `site` (`Astro.site`). Returns `[]`
+ * when the group has no non-draft siblings — a lone page emits no hreflang.
+ */
+export function deriveHreflangAlternates(params: {
+  entries: HreflangEntry[];
+  baseName: string;
+  site: URL | string | undefined;
+}): HreflangAlternate[] {
+  const { entries, baseName, site } = params;
+
+  const byKey = new Map<
+    string,
+    { tag: string; route: string; isBase: boolean }
+  >();
+  let base: { route: string } | undefined;
+  for (const entry of entries) {
+    if (entry.draft) continue; // never advertise a draft sibling/base
+    const { base: entryBase, locale } = parseEntryId(entry.id);
+    if (entryBase !== baseName) continue;
+    const isBase = !locale;
+    const tag = isBase ? DEFAULT_LOCALE : normalizeBcp47(locale);
+    const key = tag.toLowerCase();
+    if (isBase) base = { route: entry.route };
+    if (!byKey.has(key)) byKey.set(key, { tag, route: entry.route, isBase });
+  }
+
+  const hasSibling = [...byKey.values()].some((alt) => !alt.isBase);
+  if (!hasSibling) return [];
+
+  const ordered = [...byKey.values()].sort((a, b) => {
+    if (a.isBase !== b.isBase) return a.isBase ? -1 : 1; // base first
+    return a.tag.localeCompare(b.tag);
+  });
+  const alternates: HreflangAlternate[] = ordered.map((alt) => ({
+    hreflang: alt.tag,
+    href: absolute(alt.route, site),
+  }));
+  if (base) {
+    alternates.push({
+      hreflang: "x-default",
+      href: absolute(base.route, site),
+    });
+  }
+  return alternates;
+}

package/src/lib/locales.ts

@@ -0,0 +1,92 @@
+import { z } from "astro/zod";
+
+// Locale sibling entries (starter 2.8.0): a translated page is a first-class
+// content entry next to its base — `src/content/pages/<page>.<locale>.json`
+// with the lowercased locale as both the filename suffix and the root-level
+// route prefix (`/es/pricing`); the unsuffixed base stays the x-default.
+// Site chrome follows the same model (`src/content/chrome.<locale>.json`),
+// resolved per request path with fallback to the base chrome. `<html lang>`
+// and hreflang alternates are derived from the entry locale (see
+// ./hreflang.ts).
+
+/**
+ * Lowercased locale segment grammar (`es`, `pt-br`): language subtag plus
+ * optional extra subtags, all lowercase — the form used in entry filenames,
+ * entry ids, and route prefixes.
+ */
+export const LOCALE_SEGMENT_RE = /^[a-z]{2,3}(?:-[a-z0-9]{2,8})*$/;
+
+/** The platform x-default: base entries carry no suffix and never get one. */
+export const DEFAULT_LOCALE = "en";
+
+/**
+ * Split a collection entry id into its base page and optional locale:
+ * `home` → {base:"home"}, `home.es` → {base:"home", locale:"es"},
+ * `chrome.pt-br` → {base:"chrome", locale:"pt-br"}. Base names never contain
+ * dots, so any well-formed lowercased locale suffix IS a sibling id.
+ *
+ * KEEP IN SYNC with `apps/agent-mvp/src/locales.ts#parseEntryId` — the agent
+ * writes the sibling ids the site reads back (out-of-workspace duplication,
+ * same pattern as the special-input mirrors).
+ */
+export function parseEntryId(id: string): { base: string; locale?: string } {
+  const dot = id.indexOf(".");
+  if (dot === -1) return { base: id };
+  const base = id.slice(0, dot);
+  const suffix = id.slice(dot + 1);
+  if (base && LOCALE_SEGMENT_RE.test(suffix)) return { base, locale: suffix };
+  return { base: id };
+}
+
+/**
+ * Canonical BCP-47 casing for a locale (`pt-br` → `pt-BR`, `ES` → `es`):
+ * language subtag lowercased, 4-alpha script subtags Titlecased, other
+ * subtags uppercased. Files/routes use the lowercased segment; this casing is
+ * for the `<html lang>` attribute and hreflang values (starter 2.9.0). KEEP IN
+ * SYNC with `apps/agent-mvp/src/locales.ts#normalizeBcp47`.
+ */
+export function normalizeBcp47(locale: string): string {
+  const raw = locale.trim().replace(/_/g, "-");
+  if (!raw) return raw;
+  const [language, ...rest] = raw.split("-");
+  return [
+    language.toLowerCase(),
+    ...rest.map((part) =>
+      part.length === 4 && /^[a-z]+$/i.test(part)
+        ? part[0].toUpperCase() + part.slice(1).toLowerCase()
+        : part.toUpperCase(),
+    ),
+  ].join("-");
+}
+
+/**
+ * The locale segment a request path is prefixed with, if any: `/es/pricing`
+ * → `es`, `/pt-br` → `pt-br`, `/pricing` → undefined. Grammar-only — the
+ * caller decides whether a matching sibling (chrome.<locale>.json) actually
+ * exists and falls back to the base otherwise, so a page that merely LOOKS
+ * locale-shaped costs nothing.
+ */
+export function localeFromPath(pathname: string): string | undefined {
+  const [first] = pathname.split("/").filter(Boolean);
+  return first && LOCALE_SEGMENT_RE.test(first) ? first : undefined;
+}
+
+/**
+ * The `_translation` provenance block locale siblings carry (per-leaf source
+ * hashes, human-owned paths, base-entry sha). It is written and maintained by
+ * the platform agent — a brand site only needs siblings to VALIDATE, so the
+ * shape is deliberately loose: a record the schema passes through and the
+ * renderer never reads.
+ */
+export const translationProvenanceSchema = z.record(z.string(), z.unknown());
+
+/**
+ * Collection entry id from a JSON filename, preserving dots:
+ * `home.es.json` → `home.es`. The glob loader's default generateId slugifies
+ * ids (github-slugger drops dots — `home.es` would become `homees`), which
+ * breaks the `<page>.<locale>` sibling grammar the platform addresses
+ * entries by.
+ */
+export function entryIdFromFile(entry: string): string {
+  return entry.replace(/\.json$/, "");
+}

package/src/lib/sitemap/get-sitemap-paths.ts

@@ -0,0 +1,65 @@
+// SSR routes are invisible to @astrojs/sitemap (it only sees prerendered
+// pages), so list them here. This runs synchronously in Astro's config chain
+// (plain Node) so there is no `astro:content` and no `@/` alias: we read the
+// `pages` JSON collection from disk and use each entry's `route` field, the same
+// value src/pages/[...slug].astro matches against.
+//
+// Locale siblings (`<page>.<locale>.json`) are ordinary entries here: each
+// contributes its own prefixed route (`/es/example`) so every published locale
+// is in the sitemap. Drafts (siblings inherit the base's `draft`) are skipped,
+// so an unpublished translation never appears.
+//
+// `root` is the CONSUMING repo's project root, which the caller reads off
+// Astro's resolved config rather than guessing from cwd: the package sits in
+// node_modules, and a cwd-relative guess silently yields an empty list (and a
+// sitemap missing every SSR route) whenever a build is driven from elsewhere.
+import { readdirSync, readFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+
+import { DEFAULT_PAGES_DIR } from "../content-paths";
+
+export interface SitemapPathsOptions {
+  /** Page entry directory (absolute, or relative to `root`). */
+  pagesDir?: string;
+  /** The project root. Required in practice; cwd is the last-resort fallback. */
+  root?: string;
+}
+
+function resolvePagesDir({ pagesDir, root }: SitemapPathsOptions): string {
+  const dir = pagesDir ?? DEFAULT_PAGES_DIR;
+  return isAbsolute(dir) ? dir : join(root ?? process.cwd(), dir);
+}
+
+/**
+ * Every non-draft page entry's route, home excluded (@astrojs/sitemap already
+ * emits the site root). Returns `{ paths, pagesDir }` so a caller can report
+ * WHERE it looked when the answer is empty.
+ */
+export function getSitemapPaths(options: SitemapPathsOptions = {}): {
+  paths: string[];
+  entryCount: number;
+  pagesDir: string;
+} {
+  const pagesDir = resolvePagesDir(options);
+  let entries: string[];
+  try {
+    entries = readdirSync(pagesDir, { recursive: true }) as string[];
+  } catch {
+    return { paths: [], pagesDir, entryCount: 0 }; // no page entries yet
+  }
+  const jsonEntries = entries.filter((entry) => entry.endsWith(".json"));
+  const entryCount = jsonEntries.length;
+  const paths = jsonEntries
+    .filter((rel) => /\.json$/i.test(rel))
+    .map((rel) => {
+      try {
+        const data = JSON.parse(readFileSync(join(pagesDir, rel), "utf8"));
+        if (data.draft || typeof data.route !== "string") return null;
+        return data.route as string;
+      } catch {
+        return null; // malformed entry; the build will surface the schema error
+      }
+    })
+    .filter((path): path is string => path !== null && path !== "/");
+  return { paths, pagesDir, entryCount };
+}

package/src/lib/sitemap/index.ts

@@ -0,0 +1,19 @@
+// The sitemap machinery, as astro.config consumes it (the config preset wires
+// `sitemapWithCustomPages` already). Route HANDLERS live in
+// @iterant/site-runtime/routes so a route file never pulls @astrojs/sitemap
+// into the server bundle.
+export { DEFAULT_PAGES_DIR } from "../content-paths";
+export { getSitemapPaths, type SitemapPathsOptions } from "./get-sitemap-paths";
+export {
+  sitemapWithCustomPages,
+  type SitemapWithCustomPagesOptions,
+} from "./sitemap-with-custom-pages-plugin";
+export {
+  EMPTY_SITEMAP_HEADERS,
+  EMPTY_URLSET,
+  SITEMAP_HEADERS,
+  fetchUpstream,
+  normalizeSourceUrls,
+  parseSitemapIndex,
+  rewriteSitemapDomain,
+} from "./shared";

package/src/lib/sitemap/routes.ts

@@ -0,0 +1,141 @@
+import type { APIRoute } from "astro";
+
+import {
+  EMPTY_SITEMAP_HEADERS,
+  EMPTY_URLSET,
+  fetchUpstream,
+  normalizeSourceUrls,
+  parseSitemapIndex,
+  rewriteSitemapDomain,
+  SITEMAP_HEADERS,
+} from "./shared";
+
+// The two sitemap-proxy handlers. They stay behind visible repo routes (the
+// repo owns whether a URL exists; the package owns what it answers):
+//
+//   src/pages/sitemap.xml.ts
+//   ---
+//   export const prerender = false;
+//   export const GET = createSitemapRoute({
+//     sourceSitemapUrl: SITE_CONFIG.sourceSitemapUrl,
+//   });
+//
+//   src/pages/proxied-sitemap-[i].xml.ts
+//   ---
+//   export const prerender = false;
+//   export const GET = createProxiedSitemapRoute({
+//     sourceSitemapUrl: SITE_CONFIG.sourceSitemapUrl,
+//   });
+//
+// With no upstream configured both answer 404, which is what the routes did
+// when they were conditionally injected: a brand with no mirrored sitemap
+// serves only the generated sitemap-index.xml.
+
+export interface SitemapRouteOptions {
+  /** The brand's `SITE_CONFIG.sourceSitemapUrl` (string or array, "" to disable). */
+  sourceSitemapUrl: string | string[];
+}
+
+/**
+ * /sitemap.xml: a sitemap proxied from the configured upstream with every URL's
+ * host rewritten to this site's domain. A `<sitemapindex>` upstream (or an array
+ * config) is served as an index whose entries are /proxied-sitemap-[i].xml.
+ */
+export function createSitemapRoute({
+  sourceSitemapUrl,
+}: SitemapRouteOptions): APIRoute {
+  return async ({ site }) => {
+    const urls = normalizeSourceUrls(sourceSitemapUrl);
+    if (urls.length === 0) {
+      return new Response("Not found", { status: 404 });
+    }
+    if (!site) {
+      return new Response(EMPTY_URLSET, { headers: EMPTY_SITEMAP_HEADERS });
+    }
+
+    // Array config: one /proxied-sitemap-N.xml slot per entry. The entry route
+    // fetches each upstream URL on demand.
+    if (urls.length > 1) {
+      return new Response(buildProxyIndex(urls.length, site.origin), {
+        headers: SITEMAP_HEADERS,
+      });
+    }
+
+    // Single URL: mirror the upstream's shape (urlset stays urlset; index becomes
+    // a proxied index).
+    const xml = await fetchUpstream(urls[0]);
+    if (xml === null) {
+      return new Response(EMPTY_URLSET, { headers: EMPTY_SITEMAP_HEADERS });
+    }
+    const entries = parseSitemapIndex(xml);
+    const body = entries
+      ? buildProxyIndex(entries.length, site.origin)
+      : rewriteSitemapDomain(xml, site.origin);
+    return new Response(body, { headers: SITEMAP_HEADERS });
+  };
+}
+
+/**
+ * /proxied-sitemap-<i>.xml: the i-th upstream urlset, host-rewritten. `i` only
+ * indexes the upstream's own entries or the operator-supplied array, never a
+ * caller-supplied URL.
+ */
+export function createProxiedSitemapRoute({
+  sourceSitemapUrl,
+}: SitemapRouteOptions): APIRoute {
+  return async ({ params, site }) => {
+    const urls = normalizeSourceUrls(sourceSitemapUrl);
+    if (urls.length === 0 || !/^\d+$/.test(params.i ?? "")) {
+      return new Response("Not found", { status: 404 });
+    }
+    if (!site) {
+      return new Response(EMPTY_URLSET, { headers: EMPTY_SITEMAP_HEADERS });
+    }
+    const idx = Number(params.i);
+
+    // Array config: index directly into the array. Single URL: fetch the upstream
+    // <sitemapindex> and take its i-th <loc>.
+    let entryUrl: string | undefined;
+    if (urls.length > 1) {
+      entryUrl = urls[idx];
+    } else {
+      const indexXml = await fetchUpstream(urls[0]);
+      const entries = indexXml ? parseSitemapIndex(indexXml) : null;
+      entryUrl = entries?.[idx];
+    }
+    if (!entryUrl) {
+      return new Response("Not found", { status: 404 });
+    }
+
+    const xml = await fetchUpstream(entryUrl);
+    if (xml === null) {
+      return new Response(EMPTY_URLSET, { headers: EMPTY_SITEMAP_HEADERS });
+    }
+    if (parseSitemapIndex(xml)) {
+      // Nested index: fail safe rather than emit URLs we don't serve.
+      console.warn(
+        `[sitemap-proxy] nested sitemap index not supported: ${entryUrl}`,
+      );
+      return new Response(EMPTY_URLSET, { headers: EMPTY_SITEMAP_HEADERS });
+    }
+
+    return new Response(rewriteSitemapDomain(xml, site.origin), {
+      headers: SITEMAP_HEADERS,
+    });
+  };
+}
+
+// A <sitemapindex> whose entries are our own /proxied-sitemap-<i>.xml URLs.
+function buildProxyIndex(count: number, origin: string): string {
+  const entries = Array.from(
+    { length: count },
+    (_, i) =>
+      `  <sitemap><loc>${origin}/proxied-sitemap-${i}.xml</loc></sitemap>`,
+  ).join("\n");
+  return (
+    '<?xml version="1.0" encoding="UTF-8"?>\n' +
+    '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n' +
+    `${entries}\n` +
+    "</sitemapindex>\n"
+  );
+}