@warlock.js/sitemap 5.15.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog — @warlock.js/sitemap
+
+All notable changes to `@warlock.js/sitemap` are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
+
+## 5.15.0 - 2026-09-18
+
+### Added
+
+- New package: runtime `sitemap.xml` generation. Walks the page registry at runtime, applies the framework's exclusion rules (not-found route, error page, `metadata.robots: noindex`, `sitemap: false`), collects the entries a page's `sitemap` export returns, and reports — in development — any dynamic route left with no `sitemap` export so it is never silently dropped from the generated XML.
+- Zero runtime dependencies, in the same spirit as `@warlock.js/fs`: XML serialization is string-building plus escaping, and needs no library.
+- Usable in three ways: standalone in any Node app (`collectSitemapEntries` + `buildSitemapXml`, no Warlock at all), in an API-only Warlock app via `sitemapConnector({ entries })`, and in a Warlock web app from the page registry. `@warlock.js/core` and `@warlock.js/web` are **optional** peers — everything except `sitemapConnector()` imports nothing from either, and the connector reaches them only through a lazy `import()`.
+- `sitemapConnector({ entries })` merges app-supplied entries with page-derived ones, deduplicated by path with the app-supplied entry winning. With neither source available the connector refuses to boot (`NoPageRegistryError`) instead of serving an empty `<urlset>` that looks correct.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Hassan Zohdy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,185 @@
+# @warlock.js/sitemap
+
+A `sitemap.xml` generator: exclusion rules (`noindex`, `sitemap: false`),
+per-entry `changefreq`/`priority` defaults, and a loud diagnostic when a
+dynamic route can't be enumerated. `@warlock.js/core` and `@warlock.js/web`
+are **optional peers** — everything except `sitemapConnector()` imports
+nothing from either, and `sitemapConnector()` itself only reaches them
+through a lazy `import()` at boot. Three ways to use it, below.
+
+Generation only in this release. No remote sitemap parser — emitting XML
+needs no dependency; parsing one does, and nothing needs it yet.
+
+## Install
+
+```bash
+npm install @warlock.js/sitemap
+```
+
+## Mode 1 — Standalone, any Node app
+
+No Warlock at all. Build the `RoutablePage[]` array yourself — from a route
+table, a database, wherever your app already knows its own URLs — and call
+`collectSitemapEntries` + `buildSitemapXml` directly. Nothing on this path
+resolves `@warlock.js/core` or `@warlock.js/web`.
+
+```ts
+import express from "express";
+import { buildSitemapXml, collectSitemapEntries, type RoutablePage } from "@warlock.js/sitemap";
+
+const app = express();
+
+app.get("/sitemap.xml", async (_req, res) => {
+  const pages: RoutablePage[] = [
+    { routeName: "home", routePath: "/" },
+    { routeName: "about", routePath: "/about" },
+    {
+      routeName: "post-details",
+      routePath: "/posts/:id",
+      sitemap: async () => (await db.posts.find()).map((post) => ({ path: `/posts/${post.slug}` })),
+    },
+  ];
+
+  const { entries } = await collectSitemapEntries(pages, {
+    defaults: { changefreq: "weekly", priority: 0.5 },
+  });
+
+  const xml = buildSitemapXml(entries, "https://example.com");
+
+  res.type("application/xml").send(xml);
+});
+```
+
+## Mode 2 — Warlock, API-only (no `@warlock.js/web`)
+
+An API-only Warlock app has no page registry — `listRoutablePages()` would
+have nothing to list. Pass `entries` and `sitemapConnector()` uses it instead;
+`@warlock.js/web` is not required on this path.
+
+```ts
+// warlock.config.ts
+import { sitemapConnector } from "@warlock.js/sitemap";
+
+export default defineConfig({
+  connectors: [
+    sitemapConnector({
+      entries: async () => {
+        const products = await db.products.find();
+
+        return products.map((product) => ({ path: `/products/${product.slug}` }));
+      },
+    }),
+  ],
+});
+```
+
+If neither `entries` nor `@warlock.js/web` is available, the connector
+refuses to boot rather than serving an empty `<urlset>` — see
+[`NoPageRegistryError`](#no-page-registry-no-entries) below.
+
+## Mode 3 — Warlock web
+
+```bash
+warlock add sitemap
+```
+
+writes `src/config/sitemap.ts`:
+
+```ts
+export const sitemapConfig: SitemapConfig = {
+  enabled: true,
+  path: "/sitemap.xml",
+  defaults: { changefreq: "weekly", priority: 0.5 },
+};
+```
+
+`sitemapConnector()` reads the page registry from `@warlock.js/web`'s
+`listRoutablePages()` on every request — not once at boot — so it reflects
+the app's current shape under `warlock dev` too.
+
+Only a dynamic route needs a page-level `sitemap` export; a static route is
+included automatically at its own path.
+
+```ts
+// any *.page.tsx
+export const sitemap: SitemapEntries = async () => [
+  { path: "/posts/hello-world", lastmod: "2026-09-17", priority: 0.8 },
+];
+
+// or, to keep a page out of the sitemap deliberately
+export const sitemap = false;
+```
+
+`changefreq` and `priority` are per-entry and optional — they fall back to
+the config's `defaults`. They are not part of `PageMetadata`; they mean
+nothing outside a sitemap.
+
+**A dynamic route with no `sitemap` export is silently omitted from the
+generated XML if nobody is watching.** In development this package reports it
+instead: a dynamic route cannot be enumerated without application data, and
+the framework's whole job here is to make sure you find out, rather than
+shipping a sitemap that looks complete while it quietly drops every product
+page on the site.
+
+If a project has both a page registry **and** `entries`, they are combined —
+`entries` are added to the page-derived entries, not a replacement for them.
+Where the same `path` appears in both, the `entries` version wins.
+
+## Config reference (`src/config/sitemap.ts`)
+
+| key | meaning |
+| --- | --- |
+| `enabled` | no-op when not `true` — the connector registers no route |
+| `path` | defaults to `/sitemap.xml` |
+| `defaults.changefreq` / `defaults.priority` | applied to any entry that omits them, page-derived or app-supplied |
+
+The public origin the sitemap is served from is **not** configured here — it
+lives in `app.publicUrl` (or the `PUBLIC_APP_URL` environment variable), one
+level up in `@warlock.js/core`, because canonical links, OG tags and absolute
+mail URLs need the same value. If the sitemap is `enabled` and no origin is
+configured, the app refuses to boot rather than guess — a sitemap served with
+the wrong host is worse than one that never started.
+
+## What goes in the sitemap
+
+| case | behaviour |
+| --- | --- |
+| static route | included |
+| not-found route | excluded |
+| error page | excluded — it isn't a routable page at all |
+| page whose `metadata.robots` says `noindex` | excluded |
+| page exporting `sitemap: false` | excluded |
+| dynamic route (`[id]`, `[...slug]`) **with** a `sitemap` export | the entries that export returns |
+| dynamic route **without** a `sitemap` export | **omitted, and named in a dev-mode diagnostic** |
+| `sitemapConnector({ entries })` result | added to the above, `entries` wins on a `path` collision |
+
+## No page registry, no `entries`
+
+If `@warlock.js/web` is not installed and no `entries` option is supplied,
+`sitemapConnector()` throws `NoPageRegistryError` at `boot()` — before the
+route is even registered — rather than serving an empty sitemap that looks
+correct. Fix it either way:
+
+```
+Sitemap is enabled but has no source of entries: `@warlock.js/web` is not installed,
+so there is no page registry to read, and no `entries` option was supplied either.
+Fix this by installing `@warlock.js/web`, or by passing
+`sitemapConnector({ entries: async () => [...] })` with your own supplier.
+```
+
+## Full documentation
+
+The complete guide lives at
+**[warlock.js.org](https://warlock.js.org/v/latest/sitemap/)**.
+
+## Tests
+
+This package uses Vitest:
+
+```bash
+yarn test
+```
+
+## License
+
+MIT

package/cjs/index.cjs

@@ -0,0 +1,279 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region ../sitemap/src/collect-entries.ts
+const DYNAMIC_SEGMENT = /(^|\/):[A-Za-z_][A-Za-z0-9_]*/;
+/** A route path carries a dynamic segment (`[id]` -> `:id`) it cannot enumerate on its own. */
+function isDynamicRoutePath(routePath) {
+	return DYNAMIC_SEGMENT.test(routePath);
+}
+function isNoindex(robots) {
+	return robots !== void 0 && /noindex/i.test(robots);
+}
+/** Applies the config's `defaults` to any entry that omits `changefreq`/`priority` — shared by page-derived and app-supplied entries alike. */
+function withDefaults(entry, defaults) {
+	return {
+		...entry,
+		changefreq: entry.changefreq ?? defaults?.changefreq,
+		priority: entry.priority ?? defaults?.priority
+	};
+}
+/**
+* Combines page-derived entries with app-supplied ones (`SitemapConnectorOptions.entries`),
+* deduplicating by `path`. App-supplied entries are ADDED, not substituted — an
+* app with both a page graph and extra URLs (e.g. rows the page graph can't
+* see) wants both — but where the same path appears in both, the app-supplied
+* entry wins, since it was written for that exact path on purpose.
+*/
+function mergeSitemapEntries(pageEntries, appEntries) {
+	const byPath = /* @__PURE__ */ new Map();
+	for (const entry of pageEntries) byPath.set(entry.path, entry);
+	for (const entry of appEntries) byPath.set(entry.path, entry);
+	return Array.from(byPath.values());
+}
+/**
+* Walks the routable pages and produces the entries + the unresolved-dynamic
+* diagnostic input, applying every exclusion rule:
+*
+* - `metadata.robots` says `noindex` -> excluded.
+* - `sitemap: false` -> excluded.
+* - a `sitemap` export (any route) -> its returned entries, in place of the
+*   page's own route path.
+* - a dynamic route with no `sitemap` export -> omitted, name collected.
+* - everything else (static routes) -> one entry at the page's own route path.
+*
+* Not-found and error pages are excluded by construction: the caller is
+* expected to hand this only `DiscoveredRoutablePage`-derived entries, and
+* the not-found route is never one of those (`@warlock.js/web`'s discovery
+* reports it as a routable page for the client matcher, but the runtime
+* wiring filters it out before calling here — see the sitemap README).
+*/
+async function collectSitemapEntries(pages, options = {}) {
+	const entries = [];
+	const unresolvedDynamicRoutes = [];
+	for (const page of pages) {
+		if (isNoindex(page.robots)) continue;
+		if (page.sitemap === false) continue;
+		if (typeof page.sitemap === "function") {
+			const produced = await page.sitemap();
+			for (const entry of produced) entries.push(withDefaults(entry, options.defaults));
+			continue;
+		}
+		if (isDynamicRoutePath(page.routePath)) {
+			unresolvedDynamicRoutes.push(page.routeName);
+			continue;
+		}
+		entries.push(withDefaults({ path: page.routePath }, options.defaults));
+	}
+	return {
+		entries,
+		unresolvedDynamicRoutes
+	};
+}
+
+//#endregion
+//#region ../sitemap/src/diagnostic.ts
+/**
+* The dev-mode diagnostic for dynamic routes {@link collectSitemapEntries}
+* (`collect-entries.ts`) could not enumerate — the whole reason this package
+* is written carefully. A dynamic route cannot be enumerated without
+* application data; what the framework controls is whether the developer
+* finds out. Returns `undefined` when there is nothing to report, so a caller
+* can `if (message) console.warn(message)` without an extra length check.
+*/
+function describeUnresolvedDynamicRoutes(routeNames) {
+	if (routeNames.length === 0) return void 0;
+	const plural = routeNames.length === 1 ? "" : "s";
+	const named = routeNames.map((name) => `  - ${name}`).join("\n");
+	return `[warlock:sitemap] ${routeNames.length} dynamic route${plural} ${routeNames.length === 1 ? "has" : "have"} no \`sitemap\` export and ${routeNames.length === 1 ? "is" : "are"} OMITTED from sitemap.xml:\n${named}\nA dynamic route cannot be enumerated without application data. Add \`export const sitemap: SitemapEntries = async () => [...]\` to each page above, or \`export const sitemap = false\` to keep it out of the sitemap deliberately.`;
+}
+
+//#endregion
+//#region ../sitemap/src/url.ts
+/**
+* Joins a configured origin and an app-relative route path into one absolute
+* URL, with exactly one slash at the seam regardless of whether either side
+* already carries one.
+*/
+function joinOrigin(origin, routePath) {
+	return `${origin.endsWith("/") ? origin.slice(0, -1) : origin}${routePath.startsWith("/") ? routePath : `/${routePath}`}`;
+}
+/**
+* Raised when the sitemap is enabled but no public origin is configured.
+* Refuses to boot rather than falling back to a request-derived origin: a
+* sitemap served with the wrong host is worse than one that refuses to
+* start, because nothing downstream ever tells you it was wrong.
+*/
+var MissingPublicUrlError = class extends Error {
+	constructor() {
+		super("Sitemap is enabled but no public origin is configured. Set `app.publicUrl` in warlock.config.ts, or the PUBLIC_APP_URL environment variable.");
+		this.name = "MissingPublicUrlError";
+	}
+};
+/**
+* The origin the sitemap is served from: `app.publicUrl` first, then the
+* `PUBLIC_APP_URL` env fallback. Throws {@link MissingPublicUrlError} when
+* neither is set — this is the boot-time check, called once, not per-request.
+*/
+function resolveOrigin(options = {}) {
+	const origin = options.publicUrl ?? options.env?.PUBLIC_APP_URL;
+	if (!origin) throw new MissingPublicUrlError();
+	return origin;
+}
+
+//#endregion
+//#region ../sitemap/src/xml.ts
+const XML_ESCAPES = {
+	"&": "&",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&apos;"
+};
+/** Escapes the five XML-significant characters. A URL's query string routinely contains `&`. */
+function escapeXml(value) {
+	return value.replace(/[&<>"']/g, (char) => XML_ESCAPES[char] ?? char);
+}
+function entryXml(entry, origin) {
+	const lines = [`  <url>`, `    <loc>${escapeXml(joinOrigin(origin, entry.path))}</loc>`];
+	if (entry.lastmod !== void 0) lines.push(`    <lastmod>${escapeXml(entry.lastmod)}</lastmod>`);
+	if (entry.changefreq !== void 0) lines.push(`    <changefreq>${entry.changefreq}</changefreq>`);
+	if (entry.priority !== void 0) lines.push(`    <priority>${entry.priority}</priority>`);
+	lines.push(`  </url>`);
+	return lines.join("\n");
+}
+/**
+* Serialises entries into a `urlset` sitemap document — the sitemaps.org
+* namespace, `<url>` per entry, element order `loc` / `lastmod` / `changefreq`
+* / `priority` (schema order; a validator that checks order rejects any other).
+*/
+function buildSitemapXml(entries, origin) {
+	const body = entries.map((entry) => entryXml(entry, origin)).join("\n");
+	return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n" + (body.length > 0 ? `${body}\n` : "") + `</urlset>\n`;
+}
+
+//#endregion
+//#region ../sitemap/src/sitemap-connector.ts
+/** Default path when `src/config/sitemap.ts` does not set one. */
+const DEFAULT_SITEMAP_PATH = "/sitemap.xml";
+/**
+* Boots after the HTTP connector (`ConnectorPriority.HTTP` is `5`) and after
+* web (`5.5`, `web-connector-factory.ts`) — the route it registers has to
+* land on the same router web's pages already share, and `listRoutablePages`
+* only has a page graph to read once web has scanned it.
+*/
+const SITEMAP_CONNECTOR_PRIORITY = 5.6;
+/**
+* Raised at `boot()` when the sitemap is enabled but has no way to produce
+* entries: `@warlock.js/web` is not installed, so there is no page registry
+* for `listRoutablePages()` to read, AND no `entries` option was supplied.
+* Refuses to boot rather than registering a route that would silently serve
+* an empty `<urlset>` — the same reasoning as {@link MissingPublicUrlError}:
+* a sitemap that looks complete while producing nothing is worse than one
+* that never started.
+*/
+var NoPageRegistryError = class extends Error {
+	constructor() {
+		super("Sitemap is enabled but has no source of entries: `@warlock.js/web` is not installed, so there is no page registry to read, and no `entries` option was supplied either. Fix this by installing `@warlock.js/web`, or by passing `sitemapConnector({ entries: async () => [...] })` with your own supplier.");
+		this.name = "NoPageRegistryError";
+	}
+};
+/** Adapts one `listRoutablePages()` result into the package's own minimal `RoutablePage` shape. */
+function toRoutablePage(page) {
+	const metadata = page.metadata;
+	const robots = metadata !== null && typeof metadata === "object" && "robots" in metadata ? metadata.robots : void 0;
+	return {
+		routeName: page.routeName,
+		routePath: page.routePath,
+		robots: typeof robots === "string" ? robots : void 0,
+		sitemap: page.sitemap
+	};
+}
+/**
+* Construct the sitemap connector.
+*
+* At `boot()`: reads the `sitemap` config (a no-op when `enabled` is not
+* `true`), resolves the public origin ONCE — failing loud via
+* {@link resolveOrigin}'s {@link MissingPublicUrlError} rather than falling
+* back to a request-derived host — and registers `GET <config.path>`.
+*
+* The route itself re-reads the page graph on every request via
+* `listRoutablePages()`, not once at boot: the registry can change under
+* `warlock dev`, and a sitemap that only reflects the app's shape at the
+* moment it booted is stale in exactly the way that made `2ede40cf`-class
+* defects expensive.
+*
+* @example
+* // warlock.config.ts
+* import { sitemapConnector } from "@warlock.js/sitemap";
+*
+* export default defineConfig({ connectors: [sitemapConnector()] });
+*/
+function sitemapConnector(options = {}) {
+	let active = false;
+	const connector = {
+		name: "sitemap",
+		priority: SITEMAP_CONNECTOR_PRIORITY,
+		lifecyclePhase: "late",
+		isActive: () => active,
+		async boot() {
+			const { config, router } = await import("@warlock.js/core");
+			const sitemapConfig = options.config ?? config.get("sitemap");
+			if (!sitemapConfig?.enabled) return;
+			const origin = resolveOrigin({
+				publicUrl: config.get("app")?.publicUrl,
+				env: process.env
+			});
+			const path = sitemapConfig.path || "/sitemap.xml";
+			let listRoutablePages;
+			try {
+				({listRoutablePages} = await import("@warlock.js/web/build"));
+			} catch {
+				listRoutablePages = void 0;
+			}
+			if (!listRoutablePages && !options.entries) throw new NoPageRegistryError();
+			router.get(path, async ({ response }) => {
+				const { entries: pageEntries, unresolvedDynamicRoutes } = await collectSitemapEntries(listRoutablePages ? (await listRoutablePages({ appRoot: process.cwd() })).map(toRoutablePage) : [], { defaults: sitemapConfig.defaults });
+				const entries = mergeSitemapEntries(pageEntries, options.entries ? (await options.entries()).map((entry) => withDefaults(entry, sitemapConfig.defaults)) : []);
+				if (process.env.NODE_ENV !== "production") {
+					const diagnostic = describeUnresolvedDynamicRoutes(unresolvedDynamicRoutes);
+					if (diagnostic) console.warn(diagnostic);
+				}
+				const xml = buildSitemapXml(entries, origin);
+				return response.setContentType("application/xml").send(xml);
+			});
+			active = true;
+		},
+		async start() {},
+		async restart() {
+			await connector.shutdown();
+			await connector.boot();
+		},
+		async shutdown() {
+			active = false;
+		},
+		shouldRestart(changedFiles) {
+			return changedFiles.some((file) => {
+				const normalized = file.replace(/\\/g, "/");
+				return normalized === "src/config/sitemap.ts" || normalized.endsWith("/src/config/sitemap.ts");
+			});
+		}
+	};
+	return connector;
+}
+
+//#endregion
+exports.DEFAULT_SITEMAP_PATH = DEFAULT_SITEMAP_PATH;
+exports.MissingPublicUrlError = MissingPublicUrlError;
+exports.NoPageRegistryError = NoPageRegistryError;
+exports.SITEMAP_CONNECTOR_PRIORITY = SITEMAP_CONNECTOR_PRIORITY;
+exports.buildSitemapXml = buildSitemapXml;
+exports.collectSitemapEntries = collectSitemapEntries;
+exports.describeUnresolvedDynamicRoutes = describeUnresolvedDynamicRoutes;
+exports.escapeXml = escapeXml;
+exports.isDynamicRoutePath = isDynamicRoutePath;
+exports.joinOrigin = joinOrigin;
+exports.mergeSitemapEntries = mergeSitemapEntries;
+exports.resolveOrigin = resolveOrigin;
+exports.sitemapConnector = sitemapConnector;
+exports.withDefaults = withDefaults;
+//# sourceMappingURL=index.cjs.map

package/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../../../../sitemap/src/collect-entries.ts","../../../../../../sitemap/src/diagnostic.ts","../../../../../../sitemap/src/url.ts","../../../../../../sitemap/src/xml.ts","../../../../../../sitemap/src/sitemap-connector.ts"],"sourcesContent":["import type { RoutablePage } from \"./routable-page\";\r\nimport type { SitemapDefaults, SitemapEntry } from \"./types\";\r\n\r\nconst DYNAMIC_SEGMENT = /(^|\\/):[A-Za-z_][A-Za-z0-9_]*/;\r\n\r\n/** A route path carries a dynamic segment (`[id]` -> `:id`) it cannot enumerate on its own. */\r\nexport function isDynamicRoutePath(routePath: string): boolean {\r\n  return DYNAMIC_SEGMENT.test(routePath);\r\n}\r\n\r\nfunction isNoindex(robots: string | undefined): boolean {\r\n  return robots !== undefined && /noindex/i.test(robots);\r\n}\r\n\r\n/** Applies the config's `defaults` to any entry that omits `changefreq`/`priority` — shared by page-derived and app-supplied entries alike. */\r\nexport function withDefaults(entry: SitemapEntry, defaults: SitemapDefaults | undefined): SitemapEntry {\r\n  return {\r\n    ...entry,\r\n    changefreq: entry.changefreq ?? defaults?.changefreq,\r\n    priority: entry.priority ?? defaults?.priority,\r\n  };\r\n}\r\n\r\n/**\r\n * Combines page-derived entries with app-supplied ones (`SitemapConnectorOptions.entries`),\r\n * deduplicating by `path`. App-supplied entries are ADDED, not substituted — an\r\n * app with both a page graph and extra URLs (e.g. rows the page graph can't\r\n * see) wants both — but where the same path appears in both, the app-supplied\r\n * entry wins, since it was written for that exact path on purpose.\r\n */\r\nexport function mergeSitemapEntries(\r\n  pageEntries: readonly SitemapEntry[],\r\n  appEntries: readonly SitemapEntry[],\r\n): SitemapEntry[] {\r\n  const byPath = new Map<string, SitemapEntry>();\r\n\r\n  for (const entry of pageEntries) byPath.set(entry.path, entry);\r\n  for (const entry of appEntries) byPath.set(entry.path, entry);\r\n\r\n  return Array.from(byPath.values());\r\n}\r\n\r\nexport type CollectSitemapEntriesOptions = {\r\n  defaults?: SitemapDefaults;\r\n};\r\n\r\nexport type CollectSitemapEntriesResult = {\r\n  entries: SitemapEntry[];\r\n  /** Route names of dynamic routes with no `sitemap` export — feed to `describeUnresolvedDynamicRoutes`. */\r\n  unresolvedDynamicRoutes: string[];\r\n};\r\n\r\n/**\r\n * Walks the routable pages and produces the entries + the unresolved-dynamic\r\n * diagnostic input, applying every exclusion rule:\r\n *\r\n * - `metadata.robots` says `noindex` -> excluded.\r\n * - `sitemap: false` -> excluded.\r\n * - a `sitemap` export (any route) -> its returned entries, in place of the\r\n *   page's own route path.\r\n * - a dynamic route with no `sitemap` export -> omitted, name collected.\r\n * - everything else (static routes) -> one entry at the page's own route path.\r\n *\r\n * Not-found and error pages are excluded by construction: the caller is\r\n * expected to hand this only `DiscoveredRoutablePage`-derived entries, and\r\n * the not-found route is never one of those (`@warlock.js/web`'s discovery\r\n * reports it as a routable page for the client matcher, but the runtime\r\n * wiring filters it out before calling here — see the sitemap README).\r\n */\r\nexport async function collectSitemapEntries(\r\n  pages: readonly RoutablePage[],\r\n  options: CollectSitemapEntriesOptions = {},\r\n): Promise<CollectSitemapEntriesResult> {\r\n  const entries: SitemapEntry[] = [];\r\n  const unresolvedDynamicRoutes: string[] = [];\r\n\r\n  for (const page of pages) {\r\n    if (isNoindex(page.robots)) continue;\r\n    if (page.sitemap === false) continue;\r\n\r\n    if (typeof page.sitemap === \"function\") {\r\n      const produced = await page.sitemap();\r\n\r\n      for (const entry of produced) entries.push(withDefaults(entry, options.defaults));\r\n\r\n      continue;\r\n    }\r\n\r\n    if (isDynamicRoutePath(page.routePath)) {\r\n      unresolvedDynamicRoutes.push(page.routeName);\r\n      continue;\r\n    }\r\n\r\n    entries.push(withDefaults({ path: page.routePath }, options.defaults));\r\n  }\r\n\r\n  return { entries, unresolvedDynamicRoutes };\r\n}\r\n","/**\n * The dev-mode diagnostic for dynamic routes {@link collectSitemapEntries}\n * (`collect-entries.ts`) could not enumerate — the whole reason this package\n * is written carefully. A dynamic route cannot be enumerated without\n * application data; what the framework controls is whether the developer\n * finds out. Returns `undefined` when there is nothing to report, so a caller\n * can `if (message) console.warn(message)` without an extra length check.\n */\nexport function describeUnresolvedDynamicRoutes(routeNames: readonly string[]): string | undefined {\n  if (routeNames.length === 0) return undefined;\n\n  const plural = routeNames.length === 1 ? \"\" : \"s\";\n  const named = routeNames.map((name) => `  - ${name}`).join(\"\\n\");\n\n  return (\n    `[warlock:sitemap] ${routeNames.length} dynamic route${plural} ` +\n    `${routeNames.length === 1 ? \"has\" : \"have\"} no \\`sitemap\\` export and ` +\n    `${routeNames.length === 1 ? \"is\" : \"are\"} OMITTED from sitemap.xml:\\n${named}\\n` +\n    \"A dynamic route cannot be enumerated without application data. Add \" +\n    \"`export const sitemap: SitemapEntries = async () => [...]` to each page above, \" +\n    \"or `export const sitemap = false` to keep it out of the sitemap deliberately.\"\n  );\n}\n","/**\n * Joins a configured origin and an app-relative route path into one absolute\n * URL, with exactly one slash at the seam regardless of whether either side\n * already carries one.\n */\nexport function joinOrigin(origin: string, routePath: string): string {\n  const trimmedOrigin = origin.endsWith(\"/\") ? origin.slice(0, -1) : origin;\n  const normalizedPath = routePath.startsWith(\"/\") ? routePath : `/${routePath}`;\n\n  return `${trimmedOrigin}${normalizedPath}`;\n}\n\n/**\n * Raised when the sitemap is enabled but no public origin is configured.\n * Refuses to boot rather than falling back to a request-derived origin: a\n * sitemap served with the wrong host is worse than one that refuses to\n * start, because nothing downstream ever tells you it was wrong.\n */\nexport class MissingPublicUrlError extends Error {\n  public constructor() {\n    super(\n      \"Sitemap is enabled but no public origin is configured. Set `app.publicUrl` \" +\n        \"in warlock.config.ts, or the PUBLIC_APP_URL environment variable.\",\n    );\n    this.name = \"MissingPublicUrlError\";\n  }\n}\n\nexport type ResolveOriginOptions = {\n  /** `app.publicUrl` from the app's config, when set. */\n  publicUrl?: string;\n  /** Defaults to `process.env`; overridable for tests. */\n  env?: Record<string, string | undefined>;\n};\n\n/**\n * The origin the sitemap is served from: `app.publicUrl` first, then the\n * `PUBLIC_APP_URL` env fallback. Throws {@link MissingPublicUrlError} when\n * neither is set — this is the boot-time check, called once, not per-request.\n */\nexport function resolveOrigin(options: ResolveOriginOptions = {}): string {\n  const origin = options.publicUrl ?? options.env?.PUBLIC_APP_URL;\n\n  if (!origin) throw new MissingPublicUrlError();\n\n  return origin;\n}\n","import type { SitemapEntry } from \"./types\";\nimport { joinOrigin } from \"./url\";\n\nconst XML_ESCAPES: Record<string, string> = {\n  \"&\": \"&amp;\",\n  \"<\": \"&lt;\",\n  \">\": \"&gt;\",\n  '\"': \"&quot;\",\n  \"'\": \"&apos;\",\n};\n\n/** Escapes the five XML-significant characters. A URL's query string routinely contains `&`. */\nexport function escapeXml(value: string): string {\n  // The character class and the table are written together, so the lookup can\n  // only miss if one is edited without the other; falling back to the original\n  // character keeps that editing mistake from silently emitting `undefined`\n  // into a URL.\n  return value.replace(/[&<>\"']/g, (char) => XML_ESCAPES[char] ?? char);\n}\n\nfunction entryXml(entry: SitemapEntry, origin: string): string {\n  const lines = [`  <url>`, `    <loc>${escapeXml(joinOrigin(origin, entry.path))}</loc>`];\n\n  if (entry.lastmod !== undefined) {\n    lines.push(`    <lastmod>${escapeXml(entry.lastmod)}</lastmod>`);\n  }\n\n  if (entry.changefreq !== undefined) {\n    lines.push(`    <changefreq>${entry.changefreq}</changefreq>`);\n  }\n\n  if (entry.priority !== undefined) {\n    lines.push(`    <priority>${entry.priority}</priority>`);\n  }\n\n  lines.push(`  </url>`);\n\n  return lines.join(\"\\n\");\n}\n\n/**\n * Serialises entries into a `urlset` sitemap document — the sitemaps.org\n * namespace, `<url>` per entry, element order `loc` / `lastmod` / `changefreq`\n * / `priority` (schema order; a validator that checks order rejects any other).\n */\nexport function buildSitemapXml(entries: readonly SitemapEntry[], origin: string): string {\n  const body = entries.map((entry) => entryXml(entry, origin)).join(\"\\n\");\n\n  return (\n    `<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n` +\n    `<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\\n` +\n    (body.length > 0 ? `${body}\\n` : \"\") +\n    `</urlset>\\n`\n  );\n}\n","/**\n * `sitemapConnector()` — the ONE thing `warlock.config.ts` imports from\n * `@warlock.js/sitemap`, and the connector `warlock add sitemap` registers.\n *\n * Deliberately a plain object with TYPE-ONLY imports from core, same\n * reasoning as `queueConnector()`/`webConnector()`: the config file that\n * constructs it must not drag core's runtime graph in at config-load time.\n * `@warlock.js/core` and `@warlock.js/web` are imported lazily, inside\n * `boot()`, where the app has already loaded both.\n */\nimport type { Connector, ConnectorLifecyclePhase, HttpContext } from \"@warlock.js/core\";\nimport { collectSitemapEntries, mergeSitemapEntries, withDefaults } from \"./collect-entries\";\nimport { describeUnresolvedDynamicRoutes } from \"./diagnostic\";\nimport type { RoutablePage } from \"./routable-page\";\nimport type { SitemapConfig, SitemapEntries } from \"./types\";\nimport { resolveOrigin } from \"./url\";\nimport { buildSitemapXml } from \"./xml\";\n\n/** Default path when `src/config/sitemap.ts` does not set one. */\nexport const DEFAULT_SITEMAP_PATH = \"/sitemap.xml\";\n\n/**\n * Boots after the HTTP connector (`ConnectorPriority.HTTP` is `5`) and after\n * web (`5.5`, `web-connector-factory.ts`) — the route it registers has to\n * land on the same router web's pages already share, and `listRoutablePages`\n * only has a page graph to read once web has scanned it.\n */\nexport const SITEMAP_CONNECTOR_PRIORITY = 5.6;\n\nexport type SitemapConnectorOptions = {\n  /** Supply the configuration directly instead of reading the `sitemap` config key (`src/config/sitemap.ts`). */\n  config?: SitemapConfig;\n  /**\n   * App-supplied entries — the only source of entries in a Warlock **API-only**\n   * project, which has no `@warlock.js/web` page registry for `listRoutablePages()`\n   * to read. When `@warlock.js/web` IS installed, these are ADDED to the\n   * page-derived entries (see {@link mergeSitemapEntries}), not substituted, so an\n   * app with both pages and extra URLs (e.g. rows a database holds) gets both.\n   */\n  entries?: SitemapEntries;\n};\n\n/**\n * Raised at `boot()` when the sitemap is enabled but has no way to produce\n * entries: `@warlock.js/web` is not installed, so there is no page registry\n * for `listRoutablePages()` to read, AND no `entries` option was supplied.\n * Refuses to boot rather than registering a route that would silently serve\n * an empty `<urlset>` — the same reasoning as {@link MissingPublicUrlError}:\n * a sitemap that looks complete while producing nothing is worse than one\n * that never started.\n */\nexport class NoPageRegistryError extends Error {\n  public constructor() {\n    super(\n      \"Sitemap is enabled but has no source of entries: `@warlock.js/web` is not installed, \" +\n        \"so there is no page registry to read, and no `entries` option was supplied either. \" +\n        \"Fix this by installing `@warlock.js/web`, or by passing \" +\n        \"`sitemapConnector({ entries: async () => [...] })` with your own supplier.\",\n    );\n    this.name = \"NoPageRegistryError\";\n  }\n}\n\n/** Adapts one `listRoutablePages()` result into the package's own minimal `RoutablePage` shape. */\nfunction toRoutablePage(page: {\n  routeName: string;\n  routePath: string;\n  metadata?: unknown;\n  sitemap?: unknown;\n}): RoutablePage {\n  const metadata = page.metadata;\n  const robots =\n    metadata !== null && typeof metadata === \"object\" && \"robots\" in metadata\n      ? (metadata as { robots?: unknown }).robots\n      : undefined;\n\n  return {\n    routeName: page.routeName,\n    routePath: page.routePath,\n    robots: typeof robots === \"string\" ? robots : undefined,\n    sitemap: page.sitemap as RoutablePage[\"sitemap\"],\n  };\n}\n\n/**\n * Construct the sitemap connector.\n *\n * At `boot()`: reads the `sitemap` config (a no-op when `enabled` is not\n * `true`), resolves the public origin ONCE — failing loud via\n * {@link resolveOrigin}'s {@link MissingPublicUrlError} rather than falling\n * back to a request-derived host — and registers `GET <config.path>`.\n *\n * The route itself re-reads the page graph on every request via\n * `listRoutablePages()`, not once at boot: the registry can change under\n * `warlock dev`, and a sitemap that only reflects the app's shape at the\n * moment it booted is stale in exactly the way that made `2ede40cf`-class\n * defects expensive.\n *\n * @example\n * // warlock.config.ts\n * import { sitemapConnector } from \"@warlock.js/sitemap\";\n *\n * export default defineConfig({ connectors: [sitemapConnector()] });\n */\nexport function sitemapConnector(options: SitemapConnectorOptions = {}): Connector {\n  let active = false;\n\n  const connector: Connector = {\n    name: \"sitemap\",\n    priority: SITEMAP_CONNECTOR_PRIORITY,\n    // Core's `ConnectorLifecyclePhase.Late`; spelled out so this module stays\n    // free of a runtime import of core, same as `queueConnector()`.\n    lifecyclePhase: \"late\" as ConnectorLifecyclePhase,\n    isActive: () => active,\n    async boot() {\n      const { config, router } = await import(\"@warlock.js/core\");\n\n      const sitemapConfig = options.config ?? config.get<SitemapConfig | undefined>(\"sitemap\");\n\n      if (!sitemapConfig?.enabled) {\n        return;\n      }\n\n      const appConfig = config.get<{ publicUrl?: string } | undefined>(\"app\");\n      const origin = resolveOrigin({ publicUrl: appConfig?.publicUrl, env: process.env });\n      const path = sitemapConfig.path || DEFAULT_SITEMAP_PATH;\n\n      // Checked once, at boot: `@warlock.js/web`'s presence can't change per\n      // request, and failing here — before the route is even registered —\n      // surfaces a misconfigured app at startup instead of on its first hit.\n      let listRoutablePages: typeof import(\"@warlock.js/web/build\").listRoutablePages | undefined;\n      try {\n        ({ listRoutablePages } = await import(\"@warlock.js/web/build\"));\n      } catch {\n        listRoutablePages = undefined;\n      }\n\n      if (!listRoutablePages && !options.entries) {\n        throw new NoPageRegistryError();\n      }\n\n      router.get(path, async ({ response }: HttpContext) => {\n        const pages = listRoutablePages\n          ? (await listRoutablePages({ appRoot: process.cwd() })).map(toRoutablePage)\n          : [];\n\n        const { entries: pageEntries, unresolvedDynamicRoutes } = await collectSitemapEntries(pages, {\n          defaults: sitemapConfig.defaults,\n        });\n\n        const appEntries = options.entries\n          ? (await options.entries()).map((entry) => withDefaults(entry, sitemapConfig.defaults))\n          : [];\n\n        const entries = mergeSitemapEntries(pageEntries, appEntries);\n\n        if (process.env.NODE_ENV !== \"production\") {\n          const diagnostic = describeUnresolvedDynamicRoutes(unresolvedDynamicRoutes);\n          if (diagnostic) console.warn(diagnostic);\n        }\n\n        const xml = buildSitemapXml(entries, origin);\n\n        return response.setContentType(\"application/xml\").send(xml);\n      });\n\n      active = true;\n    },\n    async start() {\n      // Nothing to start: the route is registered at boot, once the HTTP\n      // connector has built its server but before it listens — the same\n      // window `queueConnector()`'s dashboard mount uses.\n    },\n    async restart() {\n      await connector.shutdown();\n      await connector.boot();\n    },\n    async shutdown() {\n      active = false;\n    },\n    shouldRestart(changedFiles: string[]) {\n      return changedFiles.some((file) => {\n        const normalized = file.replace(/\\\\/g, \"/\");\n\n        return normalized === \"src/config/sitemap.ts\" || normalized.endsWith(\"/src/config/sitemap.ts\");\n      });\n    },\n  };\n\n  return connector;\n}\n"],"mappings":"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"}

package/esm/collect-entries.d.mts

@@ -0,0 +1,44 @@
+import { SitemapDefaults, SitemapEntry } from "./types.mjs";
+import { RoutablePage } from "./routable-page.mjs";
+
+//#region ../sitemap/src/collect-entries.d.ts
+/** A route path carries a dynamic segment (`[id]` -> `:id`) it cannot enumerate on its own. */
+declare function isDynamicRoutePath(routePath: string): boolean;
+/** Applies the config's `defaults` to any entry that omits `changefreq`/`priority` — shared by page-derived and app-supplied entries alike. */
+declare function withDefaults(entry: SitemapEntry, defaults: SitemapDefaults | undefined): SitemapEntry;
+/**
+ * Combines page-derived entries with app-supplied ones (`SitemapConnectorOptions.entries`),
+ * deduplicating by `path`. App-supplied entries are ADDED, not substituted — an
+ * app with both a page graph and extra URLs (e.g. rows the page graph can't
+ * see) wants both — but where the same path appears in both, the app-supplied
+ * entry wins, since it was written for that exact path on purpose.
+ */
+declare function mergeSitemapEntries(pageEntries: readonly SitemapEntry[], appEntries: readonly SitemapEntry[]): SitemapEntry[];
+type CollectSitemapEntriesOptions = {
+  defaults?: SitemapDefaults;
+};
+type CollectSitemapEntriesResult = {
+  entries: SitemapEntry[]; /** Route names of dynamic routes with no `sitemap` export — feed to `describeUnresolvedDynamicRoutes`. */
+  unresolvedDynamicRoutes: string[];
+};
+/**
+ * Walks the routable pages and produces the entries + the unresolved-dynamic
+ * diagnostic input, applying every exclusion rule:
+ *
+ * - `metadata.robots` says `noindex` -> excluded.
+ * - `sitemap: false` -> excluded.
+ * - a `sitemap` export (any route) -> its returned entries, in place of the
+ *   page's own route path.
+ * - a dynamic route with no `sitemap` export -> omitted, name collected.
+ * - everything else (static routes) -> one entry at the page's own route path.
+ *
+ * Not-found and error pages are excluded by construction: the caller is
+ * expected to hand this only `DiscoveredRoutablePage`-derived entries, and
+ * the not-found route is never one of those (`@warlock.js/web`'s discovery
+ * reports it as a routable page for the client matcher, but the runtime
+ * wiring filters it out before calling here — see the sitemap README).
+ */
+declare function collectSitemapEntries(pages: readonly RoutablePage[], options?: CollectSitemapEntriesOptions): Promise<CollectSitemapEntriesResult>;
+//#endregion
+export { CollectSitemapEntriesOptions, CollectSitemapEntriesResult, collectSitemapEntries, isDynamicRoutePath, mergeSitemapEntries, withDefaults };
+//# sourceMappingURL=collect-entries.d.mts.map

package/esm/collect-entries.mjs

@@ -0,0 +1,73 @@
+//#region ../sitemap/src/collect-entries.ts
+const DYNAMIC_SEGMENT = /(^|\/):[A-Za-z_][A-Za-z0-9_]*/;
+/** A route path carries a dynamic segment (`[id]` -> `:id`) it cannot enumerate on its own. */
+function isDynamicRoutePath(routePath) {
+	return DYNAMIC_SEGMENT.test(routePath);
+}
+function isNoindex(robots) {
+	return robots !== void 0 && /noindex/i.test(robots);
+}
+/** Applies the config's `defaults` to any entry that omits `changefreq`/`priority` — shared by page-derived and app-supplied entries alike. */
+function withDefaults(entry, defaults) {
+	return {
+		...entry,
+		changefreq: entry.changefreq ?? defaults?.changefreq,
+		priority: entry.priority ?? defaults?.priority
+	};
+}
+/**
+* Combines page-derived entries with app-supplied ones (`SitemapConnectorOptions.entries`),
+* deduplicating by `path`. App-supplied entries are ADDED, not substituted — an
+* app with both a page graph and extra URLs (e.g. rows the page graph can't
+* see) wants both — but where the same path appears in both, the app-supplied
+* entry wins, since it was written for that exact path on purpose.
+*/
+function mergeSitemapEntries(pageEntries, appEntries) {
+	const byPath = /* @__PURE__ */ new Map();
+	for (const entry of pageEntries) byPath.set(entry.path, entry);
+	for (const entry of appEntries) byPath.set(entry.path, entry);
+	return Array.from(byPath.values());
+}
+/**
+* Walks the routable pages and produces the entries + the unresolved-dynamic
+* diagnostic input, applying every exclusion rule:
+*
+* - `metadata.robots` says `noindex` -> excluded.
+* - `sitemap: false` -> excluded.
+* - a `sitemap` export (any route) -> its returned entries, in place of the
+*   page's own route path.
+* - a dynamic route with no `sitemap` export -> omitted, name collected.
+* - everything else (static routes) -> one entry at the page's own route path.
+*
+* Not-found and error pages are excluded by construction: the caller is
+* expected to hand this only `DiscoveredRoutablePage`-derived entries, and
+* the not-found route is never one of those (`@warlock.js/web`'s discovery
+* reports it as a routable page for the client matcher, but the runtime
+* wiring filters it out before calling here — see the sitemap README).
+*/
+async function collectSitemapEntries(pages, options = {}) {
+	const entries = [];
+	const unresolvedDynamicRoutes = [];
+	for (const page of pages) {
+		if (isNoindex(page.robots)) continue;
+		if (page.sitemap === false) continue;
+		if (typeof page.sitemap === "function") {
+			const produced = await page.sitemap();
+			for (const entry of produced) entries.push(withDefaults(entry, options.defaults));
+			continue;
+		}
+		if (isDynamicRoutePath(page.routePath)) {
+			unresolvedDynamicRoutes.push(page.routeName);
+			continue;
+		}
+		entries.push(withDefaults({ path: page.routePath }, options.defaults));
+	}
+	return {
+		entries,
+		unresolvedDynamicRoutes
+	};
+}
+
+//#endregion
+export { collectSitemapEntries, isDynamicRoutePath, mergeSitemapEntries, withDefaults };
+//# sourceMappingURL=collect-entries.mjs.map