vue-ssr-lite 0.0.3

package/README.md

@@ -0,0 +1,154 @@
+# vue-ssr-lite
+
+Low-configuration server-side rendering for Vue 3 + Vite applications: a
+separable SSR engine, an optional standalone Node server, a shared
+server/browser runtime, a first-class Apollo SSR adapter, and a Vite
+integration with generated (virtual) entries.
+
+Substantially lighter than Nuxt, focused on one job: give a normal Vue + Vite
+app production-grade SSR — hydration, routing integration, Apollo state
+transfer, SEO head rendering, correct HTTP statuses, secure serialization,
+static assets, health endpoints, and production serving — without hand-writing
+a Node server, SSR entries, hydration bootstraps, or build orchestration.
+
+## Default adoption (the whole thing)
+
+1. Install:
+
+```
+yarn add vue-ssr-lite
+```
+
+2. Add the Vite integration to `vite.config`:
+
+```
+import { vueSsrLite } from 'vue-ssr-lite/vite'
+
+plugins: [vue(), vueSsrLite({ app: './src/SsrApp.ts' })]
+```
+
+3. Provide the one application definition (`src/SsrApp.ts`), or scaffold it
+   with `vue-ssr-lite init`:
+
+```
+import { defineSsrApp } from 'vue-ssr-lite'
+import App from './App.vue'
+
+export default defineSsrApp({ root: App })
+```
+
+4. Use the package commands:
+
+```
+vue-ssr-lite dev     # development server (Vite middleware mode, HMR)
+vue-ssr-lite build   # client build + SSR build
+vue-ssr-lite start   # production server (no Vite required in the image)
+```
+
+That's it. There is no server file, no client entry, no server entry, no HTML
+marker knowledge, no state-global naming, no Apollo extraction wiring. The
+integration injects markers and the generated client entry into your existing
+HTML template, builds a virtual server entry, and emits a runtime manifest so
+`start` needs no build tooling.
+
+## The application definition
+
+Everything the runtime needs lives in one `defineSsrApp` call:
+
+- `root` — the root component (required; the only required field).
+- `routes` / `scrollBehavior` — optional; the package creates the router with
+  memory history on the server and web history in the browser. Router-less
+  apps are fully supported. `router` accepts an async factory for dynamic
+  router construction.
+- `apollo` — optional: `endpoint` (or `endpoints`; values may be functions of
+  the public config), `timeoutMs`, `headers`, `links` (your auth/refresh
+  links; may be a function of `{ server }`), `cacheConfig` (type policies),
+  `ssrForceFetchDelay` (hydration deduplication), and `install(app, clients,
+  context)` for library-specific provides. The adapter owns per-request
+  clients and caches, server extraction, browser restoration, timeout and
+  cancellation. Requires `@apollo/client` to be installed.
+- `config` — optional serializable public configuration (object or factory).
+  Only serialized when non-empty. Never put secrets here.
+- `head` — optional default head payload (title, description, Open Graph,
+  Twitter, canonical, favicon, JSON-LD). Pages set `useSsrContext().head`.
+- `setup({ app, router, context, apollo, server })` — install plugins,
+  provide services.
+
+Inside components/composables, `useSsrContext()` exposes the request URL,
+host, public config, hydration state, the head ref, and mutable
+`response.statusCode` / `response.redirect` — statuses are honest: a 404 page
+returns 404.
+
+## Multi-app hosting (builder/admin SPA + public SSR)
+
+```
+vueSsrLite({
+  app: './src/site/SiteSsrApp.ts',
+  template: 'site.html',
+  spa: [{ name: 'builder', template: 'index.html', hosts: ['app.example.com'], localhost: true }],
+})
+```
+
+Host classification is declarative (exact hosts and `*.wildcards`); anything
+unmatched is served by SSR — the custom-domain model. The dev server honors
+the same classification, so subdomain testing works with `*.localhost`.
+
+## Advanced tier (ERP-class applications)
+
+`createSsrServer` from `vue-ssr-lite/server` accepts programmatic options for
+request classification hooks, custom server endpoints (e.g. robots/sitemaps),
+cookie allow/deny lists, readiness probes, role-based serving for split
+deployments, error-page overrides, serialized-global and head-attribute
+overrides (migration compatibility), and a per-request CSP `nonce` provider.
+`ssrApolloNoExternal` from `vue-ssr-lite/vite` is the SSR dependency-inlining
+preset for the Apollo cluster.
+
+## Embedding the engine (no standalone server)
+
+`createSsrRequestHandler` from `vue-ssr-lite/engine` is the framework-agnostic
+core: give it `loadTemplate` and `loadRenderModule`, hand it a request
+description, and it returns `{ statusCode, headers, html }`. Mount it in an
+existing Node/Express server, tests, or serverless functions. The standalone
+server is one host of this engine, not the engine itself.
+
+## Security invariants (package-owned, not configurable)
+
+XSS-safe state serialization; escaped head rendering including JSON-LD;
+cookie allowlisting (nothing is forwarded by default); forwarded headers
+trusted only with `SSR_TRUST_PROXY`/`trustProxy`; host validation; static
+traversal guard; security headers on HTML; production error pages without
+stack traces; module scripts stripped from error shells.
+
+## SSR data rules
+
+Never share Apollo clients, caches, routers, request contexts, or refresh
+promises across requests. The runtime and adapter enforce per-request
+creation; if you build custom data layers, follow the same rule. Global
+client libraries (e.g. vue-apollo-client's `createApollo`) are for SPA
+entries only — never call them in code that runs during SSR.
+
+## Environment
+
+`NODE_ENV`, `PORT`, `HOST`, `SSR_TRUST_PROXY`. Product-specific variables
+belong to your app: map them into `config`/server options in your definition
+or server file.
+
+## Tests
+
+`yarn test` runs the package contract tests (Node's built-in test runner; no
+build step — the package ships plain ESM with hand-maintained type
+declarations).
+
+## Publishing
+
+Choose the release type and run the corresponding command:
+
+```
+npm run release:patch
+npm run release:minor
+npm run release:major
+```
+
+Each command first runs the contract tests, then updates the package version,
+creates the npm version commit and tag, and publishes the package. The tests
+also run automatically before publishing directly.

package/apollo/SsrApolloAdapter.js

@@ -0,0 +1,184 @@
+// SsrApolloAdapter — the single generic Apollo SSR integration.
+//
+// Non-negotiable contract (audited from the proven ERP runtime): one Apollo
+// client and one cache per request; ssrMode on the server; credentials
+// omitted with only the allowlist-filtered cookie header forwarded; a
+// timeout/abort fetch; cache extraction into hydration state on the server
+// and cache restoration before mount in the browser; no module-scope clients,
+// caches, or refresh coordination anywhere. Consumers contribute only
+// product-specific links (auth, refresh), cache policies, endpoints, and
+// operations.
+
+import {
+	ApolloClient,
+	ApolloLink,
+	HttpLink,
+	InMemoryCache,
+} from '@apollo/client/core'
+
+const DEFAULT_TIMEOUT_MS = 8000
+const DEFAULT_SSR_FORCE_FETCH_DELAY_MS = 150
+
+/** Fetch wrapper enforcing a per-request timeout and upstream abort chaining. */
+export const createSsrTimedFetch = (timeoutMs = DEFAULT_TIMEOUT_MS) => {
+	return async (input, init = {}) => {
+		const controller = new AbortController()
+		const upstreamSignal = init.signal
+		const abortFromUpstream = () => controller.abort()
+		const timeout = setTimeout(() => controller.abort(), timeoutMs)
+
+		if (upstreamSignal?.aborted) controller.abort()
+		else
+			upstreamSignal?.addEventListener('abort', abortFromUpstream, {
+				once: true,
+			})
+
+		try {
+			return await fetch(input, {
+				...init,
+				credentials: 'omit',
+				signal: controller.signal,
+			})
+		} finally {
+			clearTimeout(timeout)
+			upstreamSignal?.removeEventListener('abort', abortFromUpstream)
+		}
+	}
+}
+
+/**
+ * Create one request-scoped Apollo client.
+ *
+ * options:
+ * - endpoint (required): GraphQL endpoint URL.
+ * - server: true during SSR.
+ * - cookie: allowlist-filtered cookie header (server only).
+ * - timeoutMs: per-operation budget (default 8000).
+ * - headers: static or ({ server }) => object extra HTTP headers.
+ * - links: array or ({ server, context }) => array of consumer links placed
+ *   before the terminating HTTP link (auth, refresh, error mapping).
+ * - cacheConfig: InMemoryCache configuration (type policies etc.).
+ * - restoreState: extracted cache to restore (browser hydration).
+ * - ssrForceFetchDelay: hydration deduplication window (browser; default 150).
+ * - defaultOptions: Apollo default options override.
+ */
+export const createSsrApolloClient = (options) => {
+	const {
+		endpoint,
+		server = false,
+		cookie,
+		timeoutMs = DEFAULT_TIMEOUT_MS,
+		headers,
+		links,
+		cacheConfig,
+		restoreState,
+		ssrForceFetchDelay = DEFAULT_SSR_FORCE_FETCH_DELAY_MS,
+		defaultOptions,
+		context,
+	} = options
+	if (!endpoint) {
+		throw new Error('vue-ssr-lite/apollo: an endpoint is required.')
+	}
+
+	const resolvedHeaders = {
+		...(typeof headers === 'function' ? headers({ server }) : headers),
+		...(server && cookie ? { cookie } : {}),
+	}
+
+	const httpLink = new HttpLink({
+		uri: endpoint,
+		fetch: createSsrTimedFetch(timeoutMs),
+		headers: Object.keys(resolvedHeaders).length > 0 ? resolvedHeaders : undefined,
+	})
+
+	const consumerLinks =
+		typeof links === 'function' ? links({ server, context }) ?? [] : links ?? []
+
+	const cache = new InMemoryCache(cacheConfig)
+	if (!server && restoreState) cache.restore(restoreState)
+
+	return new ApolloClient({
+		ssrMode: server,
+		...(server ? {} : { ssrForceFetchDelay }),
+		link:
+			consumerLinks.length > 0
+				? ApolloLink.from([...consumerLinks, httpLink])
+				: httpLink,
+		cache,
+		defaultOptions: defaultOptions ?? {
+			query: { errorPolicy: 'all' },
+			watchQuery: { errorPolicy: 'all', fetchPolicy: 'cache-first' },
+			mutate: { errorPolicy: 'none' },
+		},
+	})
+}
+
+const resolveEndpoints = (apolloDefinition, config) => {
+	if (apolloDefinition.endpoints) {
+		const resolved = {}
+		for (const [name, value] of Object.entries(apolloDefinition.endpoints)) {
+			resolved[name] = typeof value === 'function' ? value(config) : value
+		}
+		return resolved
+	}
+	const endpoint =
+		typeof apolloDefinition.endpoint === 'function'
+			? apolloDefinition.endpoint(config)
+			: apolloDefinition.endpoint
+	return { default: endpoint }
+}
+
+/**
+ * Create the request-scoped client set declared by an application definition,
+ * with managed hydration-state extraction and restoration.
+ *
+ * State layout: a single "default" client extracts to state.apollo directly
+ * (matching the audited ERP layout); multiple clients extract to a name-keyed
+ * map under state.apollo.
+ */
+export const createSsrApolloClients = (apolloDefinition, environment) => {
+	const { server, cookie, config, state, context } = environment
+	const endpoints = resolveEndpoints(apolloDefinition, config)
+	const names = Object.keys(endpoints)
+	const single = names.length === 1 && names[0] === 'default'
+
+	const timeoutMs =
+		typeof apolloDefinition.timeoutMs === 'function'
+			? apolloDefinition.timeoutMs(config)
+			: apolloDefinition.timeoutMs
+
+	const clients = {}
+	for (const name of names) {
+		clients[name] = createSsrApolloClient({
+			endpoint: endpoints[name],
+			server,
+			cookie,
+			context,
+			timeoutMs,
+			headers: apolloDefinition.headers,
+			links: apolloDefinition.links,
+			cacheConfig: apolloDefinition.cacheConfig,
+			ssrForceFetchDelay: apolloDefinition.ssrForceFetchDelay,
+			defaultOptions: apolloDefinition.defaultOptions,
+			restoreState: server
+				? undefined
+				: single
+					? state?.apollo
+					: state?.apollo?.[name],
+		})
+	}
+
+	return {
+		clients,
+		defaultClient: clients.default ?? clients[names[0]],
+		extractInto: (targetState) => {
+			if (!server) return targetState
+			targetState.apollo = single
+				? clients.default.extract()
+				: Object.fromEntries(
+						names.map((name) => [name, clients[name].extract()]),
+					)
+			return targetState
+		},
+	}
+}

package/apollo/index.d.ts

@@ -0,0 +1,50 @@
+import type {
+	ApolloClient,
+	ApolloLink,
+	DefaultOptions,
+	InMemoryCacheConfig,
+	NormalizedCacheObject,
+} from '@apollo/client/core'
+import type { SsrApolloDefinition, SsrRequestContext } from '../index'
+
+export interface SsrApolloClientOptions {
+	endpoint: string
+	server?: boolean
+	cookie?: string
+	timeoutMs?: number
+	headers?:
+		| Record<string, string>
+		| ((environment: { server: boolean }) => Record<string, string>)
+	links?:
+		| ApolloLink[]
+		| ((environment: {
+				server: boolean
+				context?: SsrRequestContext
+		  }) => ApolloLink[])
+	cacheConfig?: InMemoryCacheConfig
+	restoreState?: NormalizedCacheObject
+	ssrForceFetchDelay?: number
+	defaultOptions?: DefaultOptions
+	context?: SsrRequestContext
+}
+
+export declare const createSsrTimedFetch: (timeoutMs?: number) => typeof fetch
+
+export declare const createSsrApolloClient: (
+	options: SsrApolloClientOptions,
+) => ApolloClient<NormalizedCacheObject>
+
+export declare const createSsrApolloClients: (
+	apolloDefinition: SsrApolloDefinition,
+	environment: {
+		server: boolean
+		cookie?: string
+		config?: Record<string, unknown>
+		state?: Record<string, unknown>
+		context?: SsrRequestContext
+	},
+) => {
+	clients: Record<string, ApolloClient<NormalizedCacheObject>>
+	defaultClient: ApolloClient<NormalizedCacheObject>
+	extractInto: (state: Record<string, unknown>) => Record<string, unknown>
+}

package/bin/vue-ssr-lite.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+// vue-ssr-lite CLI — package-managed development, build, and production
+// commands so consumers never write server or build orchestration files.
+//
+//   vue-ssr-lite dev     start the development server (Vite middleware mode)
+//   vue-ssr-lite build   build the client bundle, then the SSR bundle
+//   vue-ssr-lite start   run the production server from built output
+//   vue-ssr-lite init    scaffold a minimal application definition (optional)
+
+import { writeFile, mkdir, access } from 'node:fs/promises'
+import { resolve, dirname } from 'node:path'
+
+const [, , command = 'dev', ...rest] = process.argv
+const root = process.cwd()
+
+const readFlag = (name) => {
+	const index = rest.indexOf(`--${name}`)
+	return index >= 0 ? rest[index + 1] : undefined
+}
+
+const dev = async () => {
+	process.env.NODE_ENV ||= 'development'
+	const { createSsrServer } = await import('../server/index.js')
+	const runtime = await createSsrServer({ root, mode: 'development' })
+	await runtime.listen()
+}
+
+const start = async () => {
+	process.env.NODE_ENV ||= 'production'
+	const { createSsrServer } = await import('../server/index.js')
+	const runtime = await createSsrServer({ root, mode: 'production' })
+	await runtime.listen()
+}
+
+const build = async () => {
+	const { build: viteBuild } = await import('vite')
+	// Client build (the plugin supplies entries, markers, and the manifest).
+	await viteBuild({ root })
+	// Server build (the plugin recognizes isSsrBuild and swaps the target).
+	await viteBuild({ root, build: { ssr: true } })
+	console.log('[vue-ssr-lite] client and server builds complete.')
+}
+
+const init = async () => {
+	const appPath = readFlag('app') || 'src/SsrApp.ts'
+	const absolute = resolve(root, appPath)
+	try {
+		await access(absolute)
+		console.log(`[vue-ssr-lite] ${appPath} already exists; nothing to do.`)
+		return
+	} catch {
+		// continue
+	}
+	await mkdir(dirname(absolute), { recursive: true })
+	await writeFile(
+		absolute,
+		[
+			"import { defineSsrApp } from 'vue-ssr-lite'",
+			"import App from './App.vue'",
+			'',
+			'export default defineSsrApp({',
+			'\troot: App,',
+			'})',
+			'',
+		].join('\n'),
+	)
+	console.log(
+		`[vue-ssr-lite] created ${appPath}. Add vueSsrLite({ app: './${appPath}' }) to vite.config and use the dev/build/start commands.`,
+	)
+}
+
+const commands = { dev, build, start, init }
+const run = commands[command]
+if (!run) {
+	console.error(
+		`[vue-ssr-lite] unknown command "${command}". Available: dev, build, start, init.`,
+	)
+	process.exit(1)
+}
+run().catch((error) => {
+	console.error(error)
+	process.exit(1)
+})

package/engine/.fuse_hidden0000002d00000001

@@ -0,0 +1,166 @@
+// SsrEngineHtml — package-owned HTML document primitives.
+//
+// These are invariants, not configuration: escaping rules, XSS-safe state
+// serialization, marker names, and head-tag rendering order are identical in
+// development and production and identical across consumers. The head payload
+// contract and tag order are byte-compatible with the audited ERP renderer so
+// the ERP migration cannot change its SEO output.
+
+export const SSR_MARKERS = Object.freeze({
+	head: '<!--app-head-->',
+	html: '<!--app-html-->',
+	state: '<!--app-state-->',
+	teleports: '<!--app-teleports-->',
+})
+
+export const escapeHtml = (value) =>
+	String(value ?? '')
+		.replaceAll('&', '&amp;')
+		.replaceAll('<', '&lt;')
+		.replaceAll('>', '&gt;')
+		.replaceAll('"', '&quot;')
+		.replaceAll("'", '&#39;')
+
+export const escapeXml = (value) =>
+	String(value ?? '')
+		.replaceAll('&', '&amp;')
+		.replaceAll('<', '&lt;')
+		.replaceAll('>', '&gt;')
+		.replaceAll('"', '&quot;')
+		.replaceAll("'", '&apos;')
+
+/** XSS-safe JSON serialization for inline <script> payloads. */
+export const serializeState = (value) =>
+	JSON.stringify(value)
+		.replaceAll('<', '\\u003c')
+		.replaceAll('
', '\\u2028')
+		.replaceAll('
', '\\u2029')
+
+/**
+ * Render a head payload into escaped tags.
+ *
+ * Payload contract (all fields optional): title, description, keywords,
+ * robots, ogTitle, ogDescription, ogImage, ogImageAlt, ogUrl, ogType,
+ * ogSiteName, ogLocale, twitterCard, twitterTitle, twitterDescription,
+ * twitterImage, twitterImageAlt, twitterSite, twitterCreator, canonicalUrl,
+ * favicon, jsonLd (array of objects).
+ *
+ * Every rendered tag carries `attribute` so the browser runtime can remove
+ * server-rendered tags before the client SEO layer takes over.
+ */
+export const renderHeadTags = (payload, attribute = 'data-ssr-head') => {
+	if (!payload) return ''
+	const tags = []
+	if (payload.title) {
+		tags.push(`<title ${attribute}>${escapeHtml(payload.title)}</title>`)
+	}
+	const meta = [
+		['name', 'description', payload.description],
+		['name', 'keywords', payload.keywords],
+		['name', 'robots', payload.robots],
+		['property', 'og:title', payload.ogTitle],
+		['property', 'og:description', payload.ogDescription],
+		['property', 'og:image', payload.ogImage],
+		['property', 'og:image:alt', payload.ogImageAlt],
+		['property', 'og:url', payload.ogUrl],
+		['property', 'og:type', payload.ogType],
+		['property', 'og:site_name', payload.ogSiteName],
+		['property', 'og:locale', payload.ogLocale],
+		['name', 'twitter:card', payload.twitterCard],
+		['name', 'twitter:title', payload.twitterTitle],
+		['name', 'twitter:description', payload.twitterDescription],
+		['name', 'twitter:image', payload.twitterImage],
+		['name', 'twitter:image:alt', payload.twitterImageAlt],
+		['name', 'twitter:site', payload.twitterSite],
+		['name', 'twitter:creator', payload.twitterCreator],
+	]
+	for (const [attributeName, name, content] of meta) {
+		if (content != null && content !== '') {
+			tags.push(
+				`<meta ${attribute} ${attributeName}="${escapeHtml(name)}" content="${escapeHtml(content)}">`,
+			)
+		}
+	}
+	if (payload.canonicalUrl) {
+		tags.push(
+			`<link ${attribute} rel="canonical" href="${escapeHtml(payload.canonicalUrl)}">`,
+		)
+	}
+	if (payload.favicon) {
+		tags.push(`<link ${attribute} rel="icon" href="${escapeHtml(payload.favicon)}">`)
+	}
+	for (const block of payload.jsonLd || []) {
+		const json = JSON.stringify(block).replaceAll('<', '\\u003c')
+		tags.push(`<script ${attribute} type="application/ld+json">${json}</script>`)
+	}
+	return tags.join('')
+}
+
+/**
+ * Render the state script exposing serialized public config and hydration
+ * state on package-owned (or consumer-overridden) globals. Emits nothing when
+ * both parts are empty. `nonce` supports strict Content Security Policies.
+ */
+export const renderStateScript = (
+	{ config, state },
+	{ configKey = '__SSR_CONFIG__', stateKey = '__SSR_STATE__', nonce } = {},
+) => {
+	const parts = []
+	if (config != null && Object.keys(config).length > 0) {
+		parts.push(`window.${configKey}=${serializeState(config)}`)
+	}
+	if (state != null) {
+		parts.push(`window.${stateKey}=${serializeState(state)}`)
+	}
+	if (parts.length === 0) return ''
+	const nonceAttribute = nonce ? ` nonce="${escapeHtml(nonce)}"` : ''
+	return `<script${nonceAttribute}>${parts.join(';')}</script>`
+}
+
+/** Inject rendered fragments into a marker-carrying HTML template. */
+export const injectSsrDocument = (template, { head = '', html = '', state = '', teleports = '' }) =>
+	template
+		.replace(SSR_MARKERS.head, head)
+		.replace(SSR_MARKERS.teleports, teleports)
+		.replace(SSR_MARKERS.html, html)
+		.replace(SSR_MARKERS.state, state)
+
+/**
+ * Guarantee the four SSR markers exist in a template so consumers never learn
+ * marker names. Existing markers are left untouched; missing ones are added:
+ * head before </head>, teleports after <body>, html inside the mount element,
+ * state before </body>.
+ */
+export const ensureSsrMarkers = (template, { mountSelector = '#app' } = {}) => {
+	let html = String(template)
+	if (!html.includes(SSR_MARKERS.head)) {
+		html = html.replace(/<\/head>/i, `${SSR_MARKERS.head}\n</head>`)
+	}
+	if (!html.includes(SSR_MARKERS.teleports)) {
+		html = html.replace(/<body([^>]*)>/i, `<body$1>${SSR_MARKERS.teleports}`)
+	}
+	if (!html.includes(SSR_MARKERS.html)) {
+		const id = mountSelector.startsWith('#') ? mountSelector.slice(1) : mountSelector
+		const mountPattern = new RegExp(`(<div[^>]*id=["']${id}["'][^>]*>)(</div>)`, 'i')
+		html = html.replace(mountPattern, `$1${SSR_MARKERS.html}$2`)
+	}
+	if (!html.includes(SSR_MARKERS.state)) {
+		html = html.replace(/<\/body>/i, `${SSR_MARKERS.state}\n</body>`)
+	}
+	return html
+}
+
+/** Generic accessible error markup used by fallback shells (overridable upstream). */
+export const renderErrorMarkup = (title, message) => `
+<main id="main-content" style="min-height:70vh;display:grid;place-items:center;padding:2rem;text-align:center;font-family:system-ui,sans-serif" tabindex="-1">
+	<div><h1>${escapeHtml(title)}</h1><p>${escapeHtml(message)}</p><p><a href="/">Return home</a></p></div>
+</main>`
+
+/** Sitemap primitives shared by consumers that serve SEO XML from the server. */
+export const renderSitemapUrlSet = (urls) => {
+	const uniqueUrls = [...new Set(urls)]
+	return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">${uniqueUrls.map((url) => `\n  <url><loc>${escapeXml(url)}</loc></url>`).join('')}\n</urlset>\n`
+}
+
+export const renderSitemapIndex = (urls) =>
+	`<?xml version="1.0" encoding="UTF-8"?>\n<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">${urls.map((url) => `\n  <sitemap><loc>${escapeXml(url)}</loc></sitemap>`).join('')}\n</sitemapindex>\n`